# Antigravity Orchestrator: How to Use Carbon and Hydrogen in One Task

The new Ultra option switches between planning and implementation without turning every coding request into a parallel agent swarm.

By Paras Madan | 2026-11-13

Google introduced Orchestrator in Antigravity on November 12. It combines Gemini 4 Carbon and Gemini 4 Hydrogen within one task, handing work between them as the task develops. The option is rolling out to Google AI Ultra subscribers, and it has a fixed reasoning configuration rather than an adjustable effort setting.

The practical use is a coding job whose difficulty changes halfway through: understanding a tangled dependency needs careful judgment, while applying the agreed change and checking it may not. You no longer have to choose one model for every step of that job.

## Select Orchestrator in the app or CLI

The [model-selection documentation](https://antigravity.google/docs/models/) places Orchestrator in the selector below the conversation prompt. In the CLI, run `/model` and select it, or start with:

```bash
agy --model Orchestrator
```

Run `agy models` to check the identifiers available to your account. If Orchestrator is missing, check the account and entitlement before assuming your prompt is wrong. The current availability table lists Ultra, not Pro or Enterprise, for this option.

Do not append an effort override: `/effort` and `--effort` do not apply to Orchestrator. Select Carbon or Hydrogen directly if you need a particular thinking level. Orchestrator is also distinct from parallel subagents: it coordinates model handoffs inside a single agent conversation.

These are documented setup instructions, not commands I have run against an Antigravity account.

## What happens between planning and implementation

The [Antigravity announcement](https://antigravity.google/blog/gemini-4-hydrogen-in-google-antigravity) describes Carbon examining the problem and forming a plan, followed by Hydrogen implementing changes and running checks. If execution reveals a problem with the plan, control can return to Carbon before implementation resumes.

That is different from picking a cheap model once based on the first prompt. A request that initially looks routine may expose a hidden assumption after a failing test. The valuable part of the handoff is the opportunity to reconsider that assumption, rather than letting the execution model keep making local patches to a bad plan.

It does not remove your responsibility to define a correct result. If the task only says “make checkout work,” a polished plan can still solve the wrong problem. Specify observable behaviour and important boundaries before asking the agent to edit anything.

## A bounded task to try first

I would start with a small repository change that has a reproducible failure and an existing test suite. Here is a suggested prompt, not a tested result:

```text
Fix the checkout bug where an expired coupon is accepted.
First reproduce it and identify the code responsible.
Preserve the existing public API and rounding behaviour.
Add a regression test for the expired coupon and check that
valid coupons still work. Do not change dependencies or
unrelated files. If the fix requires a schema or API change,
stop and explain that decision before implementing it.
Report the tests actually run, their outcomes, and anything
that remains unverified.
```

The instruction to stop on a schema or API change creates a useful boundary between a local fix and a wider design decision. It also makes the final review easier: you can check whether the change stayed inside the problem you authorized.

Before running a comparison, use an isolated branch or copy and record the starting commit. Give the same task to your existing configuration and Orchestrator separately. Compare the final diff, passing regression checks, elapsed time, quota consumed and the amount of human repair required. Do not let one run inherit the other's completed fix.

## When Hydrogen alone is the better starting point

For a task with settled requirements, such as updating a short document or writing tests for an already specified function, I would try Hydrogen directly first. Adding a separate planning stage is only worthwhile if it improves the outcome enough to justify the extra work.

For an unclear multi-file bug or a feature touching several assumptions, Orchestrator is a more interesting candidate. For work where you deliberately want the same frontier model examining every intermediate step, choose Carbon directly and compare the result. These are selection heuristics, not measured rankings of the three configurations.

Google reports quota and speed improvements on its benchmark, but a quota reduction is not automatically an equivalent reduction in a subscription bill. More importantly, those averages do not tell you whether your repository needs more retries or review. **Judge the completed patch, not the elegance of the model handoff.**

The useful change is that planning and execution no longer have to share one model choice. Keep the acceptance criteria stable while you test that separation; otherwise you will not know whether you bought efficiency or simply accepted a weaker result.

I’m Paras. I work at the intersection of AI, engineering and distribution.

I help technical teams turn agent workflows and engineering decisions into clear stories developers and founders can use.

[Book a 30-minute call](https://cal.com/paras-madan/30min).