AI Intelligence

Neon Cuts Coding Task Costs

7 stories · ~7 min read

Neon Cuts Coding Task Costs

Listen

If You Only Read One Thing

Microsoft's compromised Agent Framework package could steal credentials without waiting for an agent to run. Python's startup machinery triggered the payload, outside the model's approval loop. Meanwhile, Gemini 4 Neon's independent coding results put it alongside Opus for fewer evaluated dollars. Trying another model is getting cheaper; safely trying the software around it still takes a deliberately constrained environment.

Gemini Neon Matches Opus Coding Scores for Less

Google has a credible alternative to Opus for coding agents, with an independent cost comparison to support it. Gemini 4 Neon isn't a clear capability breakthrough. It's evidence that comparable coding performance is becoming available from another supplier at a lower bill.

In Artificial Analysis's November 18 tests, Neon at extra-high effort scored 59 on its Coding Agent Index. Opus 5.5 at maximum effort scored 58. Neon cost $6.86 per evaluated coding task against Opus's $12.61, about 46% less. Those are attempted benchmark tasks, not accepted production patches, and the small score difference doesn't establish a dependable winner.

The comparison also includes the agent software: Neon ran in Antigravity CLI, while Opus ran in Claude Code. Switching an API model inside an existing agent doesn't necessarily reproduce that result. File selection, tool use and recovery after errors all affect how much work the model completes.

Google's launch report makes that dependence unusually visible. On its SWE-sweep coding evaluation, Neon scored 12.8% in the mini-SWE agent and 39% in Antigravity. That's Google's comparison, not an independent replication. Still, the size of the difference is a reason to compare complete coding systems before attributing their results to the model alone.

Neon is generally available through the paid Gemini API at $3 per million input tokens and $15 per million output tokens. Its default effort is high, so the extra-high coding result isn't a measurement of the default configuration. Antigravity access requires a paid Pro or Ultra subscription.

The immediate price comparison with Carbon is awkward. Carbon still costs $2/$10 through November 30, then rises to $4/$20. Neon therefore has higher token prices right now, despite sitting below Carbon in Google's intended lineup. That changes the calculation from Carbon's launch: the date of a trial matters alongside its reasoning setting.

The case for testing Neon is stronger than the case for declaring Opus displaced. Neon has demonstrated competitive coding at lower measured cost in its own agent. Whether that survives a switch depends on the repository, the checks and the recovery work. A matched comparison that keeps the same acceptance tests and includes failed attempts would establish whether the saving reaches ordinary development.

Microsoft's Agent Package Ran Malware Before Import

A malicious agent dependency can bypass the model's permission system entirely. Two poisoned releases of Microsoft's official agent-framework package installed code that could run when Python started, even if the application never imported the framework.

StepSecurity inspected the malicious packages: versions 1.26.1 and 1.26.2, uploaded November 17. Both have been quarantined. The second appeared after the first quarantine, showing that removing one release hadn't immediately stopped further publication.

The execution path was a .pth file in Python's installed-package directory. Python processes these files at startup and executes their import statements. Starting a test runner or another Python tool in the affected environment could therefore launch the stealer. Exposure follows the package directories that interpreter loads; it doesn't automatically extend to every virtual environment on the machine.

This matters for agent workflows because the apparent safety check often comes later. A model may ask permission before a cloud deployment while the Python process hosting it has already run dependency-supplied code. The prompt can't constrain that earlier execution. Installing dependencies in a disposable environment without deployment credentials removes an opportunity this payload was designed to exploit; it isn't a measured prevention guarantee.

The payload also tried to obtain fresh cloud identity tokens. A job with no long-lived key can still have permission to request temporary credentials. Wiz's November 18 update reports three unique successful victim-data exfiltration cases in the webhook records it examined. That is observed theft in a limited record, not an estimate of all affected installations. Wiz also says the attacker appears to have used compromised Microsoft publishing credentials; how those credentials were obtained is unknown.

Quarantining both releases limits fresh installations, but leaves already-installed startup hooks in place. In the Cursor trace breach, attackers found credentials in saved conversations. Here, starting Python could expose credentials before the agent received a task. The relevant recovery check is whether affected package files, running collectors and reachable identities are gone from rebuilt environments. A clean subsequent conversation can't establish that.

The Contrarian Take

Everyone says: Rust fixes curl's main security problem. The agent-built rewrite's README describes curl's security history as mostly memory-safety bugs, alongside integer and state-management mistakes.

Here's why that's wrong: Curl maintainer Daniel Stenberg's November 17 accounting attributes 14 of 81 vulnerabilities confirmed during 2026 to mistakes a memory-safe language would probably avoid. That's 17%, not most. His figure covers one year and his classification is a judgment; it doesn't prove a Rust implementation would reproduce all the other bugs. But translation into Rust can't by itself promise correct protocol behavior. The rewrite's documented comparisons against a C build help check compatibility at one revision. Upstream fixes still need to reach the replacement afterward.

Under the Radar

  • A failed policy hook can stop the action. Claude Code 2.1.328 adds onFailure: block to MCP-tool hooks. A failed call to a policy service can now prevent the proposed action instead of leaving failure handling implicit. An unavailable policy service can stop execution; a working service can still return a mistaken approval. The setting protects calls that actually pass through the hook. Release notes.

  • A generated plugin got a real consumer. Simon Willison released Datasette Arrows after using Claude Fable 5.2 to build a consumer of Datasette's streaming-export extension. Arrow exports can feed tools such as DuckDB and Polars. His practice is to accompany a plugin-interface feature with a plugin that uses it: that exposes integration requirements a demonstration of the interface alone can miss. No measured time saving was reported. Release.

Quick Takes

  • Repository hooks supplied another malware entry point. Bitdefender identified 22 malicious GitHub links targeting coding-agent environments. Some instructions asked an agent to run a concealed setup script; others used session-start hooks after repository trust. The latter path needs no typed prompt. Reviewing only the agent's proposed commands misses configuration that runs earlier, and trusting a project can enable more than reading its instructions. (Source)

  • OpenAI's research agents still need frequent help. OpenAI estimates that agents independently completed 46% of research tasks requiring two to four hours of human work in October, up from 23% in March. This is the lab's own estimate, rather than an independent productivity study. Even in that favorable setting, most tasks still needed intervention. Longer autonomous runs therefore need a way to surface stalled work, alongside a completion metric. (Source)

  • AI-assisted discovery reached Java's runtime. Calif's November 17 Java4Shell disclosure describes a memory-corruption flaw in OpenJDK's accelerated Base64 decoder. Calif used AI to find and develop exploits for it; the researchers supplied application-specific strategies. Exploitation requires affected software and particular x86-64 CPU features, and no universal exploit works across applications. The capability advance is finding a real, patchable flaw with human direction, rather than autonomously compromising every Java deployment. (Source)

The Thread

Consider a coding job that fixes an HTTP redirect bug. Its acceptance check sends a request to a second host and verifies that the authorization header wasn't forwarded. That case can help compare Neon with Opus, and later check a Rust replacement against the original library. But running the comparison also starts interpreters, loads dependencies and may expose credentials. As competitive models make more trials affordable, disposable test environments become more valuable: they let the same behavioral check travel between systems without giving every trial access to the developer's accounts. The additional cost belongs in model experimentation, even when it never appears on the inference invoice. A saved test can be reused; the environment that ran an unfamiliar dependency may need to be discarded.

Predictions

  • I predict: On December 1, Google's published standard Gemini API token rates will put Neon below Carbon: $3/$15 versus $4/$20 per million input/output tokens. Carbon's explicit November 30 promotion expiry supports this forecast; an extension or repricing would make it wrong. (Confidence: medium; Check by: 2026-12-02)

Issue date: 2026-11-19. Generated at 08:35 UTC.

Tomorrow morning in your inbox.

Subscribe for free. 10-minute read, every weekday.