Google Antigravity's Orchestrator Switches Models Mid-Session, Cutting Quota Use 24%

Google Antigravity announced on November 12, 2026 that Orchestrator — a new model-dropdown option for Google AI Ultra subscribers — reached near-Carbon task success on Terminal-Bench 4.1 (a benchmark for agentic coding in a terminal) while averaging 24% lower quota use and 19% faster task completion. The gains come from dynamically switching between Gemini 4 Carbon and Gemini 4 Hydrogen within a single session, rather than committing one model to an entire task.

The numbers matter because quota consumption is the binding constraint for subscribers of agentic coding tools: frontier reasoning models burn through paid limits faster than most routine work justifies. A 24% reduction in quota use, if it holds outside Google's own testing, directly extends what an Ultra subscription buys. Google did not publish full benchmark tables, so "near-Carbon" remains the company's own characterization rather than a verifiable score.

Who gets Hydrogen, and when?

The new Hydrogen model is rolling out separately in Antigravity to paid Google AI Pro and Ultra subscribers. Enterprises can access both models through Gemini for business. Google says additional models and subscription plans will be supported for Orchestrator in the future, though it named neither models nor dates.

Google positions Hydrogen as the rapid-execution counterpart to Carbon and Argon's deeper, long-horizon reasoning. That framing gives Antigravity a three-tier model family: fast execution, general reasoning, and extended deliberation. The catch is that role assignments are Google's marketing language; independent comparisons between Hydrogen and Carbon have not yet accompanied the rollout.

Why handoff mid-session instead of up front?

Orchestrator targets routine feature development and debugging, where running a frontier reasoning model and multiple parallel agents throughout a session can slow iteration and drain frontier quota. The conventional alternative is a static router: it estimates task difficulty from the opening prompt, then commits the entire task to the cheapest model it deems sufficient.

Google argues this one-time allocation fits long-running agents poorly, because a task's demands change and only become clear during execution. The claim is plausible — anyone who has watched an agent discover mid-task that a "simple" bug spans three subsystems knows upfront difficulty estimates fail. But adaptive switching introduces its own cost: each handoff is a decision Google's system can get wrong, and the announcement does not report how often misdirected handoffs occur.

Orchestrator can move in either direction between the two models as a trajectory develops. Google's worked example runs like this:

• Carbon begins with read-only investigation of dependencies, resolves ambiguities, and produces a plan containing explicit conditions that would trigger re-planning.
• Hydrogen then implements edits, updates packages, and runs tests.
• If Hydrogen meets friction, Carbon takes back control to inspect the current state, fix the plan, and continue execution.

A session can therefore call on deeper reasoning for planning or recovery without assigning every implementation step to the same model. In plain words: the expensive thinker plans and repairs, the cheaper runner executes.

What does the SDK add for developers?

Developers who want explicit assignments rather than automatic switching can connect Hydrogen and Carbon through the Antigrivity SDK. This gives them programmatic control over which model handles each role in a multi-agent workflow (a workflow where several AI agents with distinct jobs cooperate on one task).

Google's open-source issue-triage demonstration shows the pattern:

• Hydrogen agents handle incoming issue volume by triaging and coding, searching the codebase, asking clarifying questions, and iterating on user-interface changes from pull-request comments.
• A Carbon agent is assigned larger refactors, new features, and security checks.

The demonstration uses the same broad division between rapid execution and deeper reasoning, but the developer defines the boundaries instead of delegating them to Orchestrator. That choice matters for teams with compliance or review requirements: automatic model routing makes audit trails harder, while explicit SDK assignment keeps responsibility with a named model per step.

How is Orchestrator different from /swarm?

Orchestrator follows the November 10, 2026 preview of Gemini 4 Carbon and /swarm, which targeted engineering work spread across many files and test suites. According to the /swarm documentation, a coordinator can split a task among named workers handling separate files, packages, or questions, while verifiers review diffs and run tests. Workers can also receive isolated working copies of a repository.

Orchestrator addresses a different structure. It changes the model used during one evolving session rather than creating a team to work on independent pieces in parallel. The two features divide agentic work along different axes:

• Across agents, when a project can be partitioned into parallel pieces (/swarm).
• Across models, when one conversation moves between planning, execution, and repair (Orchestrator).

Why this shifts how developers choose models

The practical shift is that model choice no longer has to be a single decision at the prompt. It can become part of the workflow's architecture — adaptive under Orchestrator, or explicitly assigned through the SDK. For a market where subscriptions meter frontier-model access, moving routing decisions inside the workflow turns model selection from a preference into an engineering design choice with direct cost consequences.

The open question is measurement. Google reports aggregate gains — 24% lower quota use, 19% faster completion, near-Carbon success — but has not detailed the tasks, sample sizes, or failure modes of handoffs gone wrong. Until third-party evaluations reproduce those figures on real repositories, Orchestrator's promise is best treated as a strong design direction with vendor-supplied evidence. If the numbers survive outside Google's testing, expect every competing agentic coding product to ship mid-session model switching within a release cycle or two.