Gemini 4 Neon Orchestrator: Pair It With Hydrogen Subagents

How to run a Gemini 4 Neon orchestrator over Hydrogen subagents: the sub-task contract it writes, fan-out sizing, per-run cost math vs Carbon, and failure rules.

Leo Harrison

Leo Harrison

19 November 2026

Gemini 4 Neon Orchestrator: Pair It With Hydrogen Subagents

A Gemini 4 Neon orchestrator is a lead agent running gemini-4-neon that reads a large coding Task, splits it into independent sub-tasks, and hands each one to a cheaper Gemini 4 Hydrogen subagent. Neon spends its tokens on planning and verification. Hydrogen spends its tokens on the edits. You get Neon’s judgment without paying Neon prices for every line of code.

TL;DR

Google launched Gemini 4 Neon on November 18, 2026, at $3 per 1M input tokens and $15 per 1M output tokens. Its launch post pitches it as “a fast, high-judgment Orchestrator directing parallel Hydrogen subagents.” The pattern pays off when the orchestrator writes tight sub-task contracts, keeps workers off each other’s files, and owns the final check. Run it on a board so the plan and every worker run stay visible to your team.

What a Gemini 4 Neon orchestrator does

An orchestrator is the agent that plans and checks while other agents execute. In this setup, it does three jobs and nothing else:

  1. Plan. Read the Task and the code it touches, then decide which changes can happen independently.
  2. Dispatch. Write one sub-task per change, each with its own scope and a pass/fail check.
  3. Verify. After the workers finish, read the combined diff and confirm the parts fit together.

The orchestrator doesn’t write the feature code. Google’s launch post says Neon “cuts down on redundant file reads, shares progress as it works, and handles context compaction reliably in long sessions.” A planner reads a lot, writes a little, and has to stay coherent across a long session.

For the worker side, see Gemini 4 Hydrogen for coding agents.

Why Neon is the cheaper Gemini 4 orchestrator

Before Neon, the Gemini 4 lead role went to Carbon, the deep reasoner. Our Carbon and Hydrogen pairing guide shows that two-model split. Neon changes the math from December 1.

Model Input / output per 1M tokens Role in this pattern
Gemini 4 Hydrogen $1.50 / $7.50 Subagent: one scoped edit per run
Gemini 4 Neon $3 / $15 ($0.15 cached input) Orchestrator: plan, dispatch, verify
Gemini 4 Carbon $2 / $10 through Nov 30, then $4 / $20 Escalation for the hardest sub-tasks

Two facts set the cost case. Per token, Neon is 25% cheaper than Carbon from December 1. Google also reports that at its default high thinking level, Neon has “a 32% lower cost per task than Carbon,” because it finishes with fewer tokens. That’s Google’s measurement, not yours: test it on your repository first.

A worked cost example for one orchestrated run

Here’s the arithmetic for a refactor that touches four modules. The token counts are assumptions for illustration, not measurements:

  • Neon plan pass: 250K input, 15K output. That’s $0.75 + $0.225 = $0.975.
  • Neon verify pass: 150K input, 8K output. That’s $0.45 + $0.12 = $0.57.
  • Four Hydrogen subagents: 200K input and 30K output each. That’s $0.525 per worker, $2.10 total.

The orchestrated run costs $3.645. With Carbon in the lead at its December rate, the same tokens cost $4.16. All five passes on Neon cost $5.745. The saving comes from moving most tokens onto the cheaper worker.

A bar chart comparing one four-module refactor under three setups: a Neon orchestrator with Hydrogen subagents at $3.65, a Carbon orchestrator with Hydrogen subagents at $4.16 at December pricing, and all-Neon at $5.75

Caching tilts it further. Neon bills cached input at $0.15 per 1M tokens, a 95% discount. If the verify pass re-reads 100K tokens the plan pass already loaded, those tokens cost $0.015 instead of $0.30.

One honest caveat: until November 30, Carbon’s introductory $2 / $10 rate is cheaper per token than Neon. On the same token counts, a Carbon lead costs $1.03 for both passes against Neon’s $1.545. If you’re testing this month, compare cost per finished Task, not per token.

Write the sub-task contract

A vague sub-task makes a Hydrogen run wander, read the whole repository, and burn the savings above. Every sub-task the orchestrator files should carry five fields:

  1. Goal: one sentence describing the change.
  2. In scope: the exact files or directories the worker may edit.
  3. Out of scope: files the worker must not touch, usually the ones another sub-task owns.
  4. Done when: a command that passes or fails, such as a test target.
  5. Stop condition: what to do when the check can’t pass, which is stop and report.

Put this template in the orchestrator’s instructions so every plan comes out the same shape:

Goal: Move date formatting in billing/ to the shared formatDate helper.
In scope: src/billing/**, src/billing/__tests__/**
Out of scope: src/shared/format.ts (owned by sub-task 1), src/invoices/**
Done when: npm test -- billing passes with no new warnings.
Stop condition: if a caller outside billing/ breaks, stop and comment
  the failing file and error. Do not edit outside scope.

The out-of-scope line keeps four parallel workers from writing conflicting edits to one shared file.

How many Hydrogen subagents should one orchestrator run?

Start with three to five. Split by file ownership, not by step count. Two sub-tasks that both edit src/shared/format.ts aren’t parallel work, they’re a merge conflict waiting to happen. When one change depends on another, make the dependency explicit and run it first. The shared helper lands before the callers that import it.

Run the Neon orchestrator on a Sharkly board

Google runs this pattern in Google Antigravity, where the launch demos use /swarm to fan work out. That works inside one person’s session. On a team, others need to see the plan, which worker stalled, and who signs off.

Sharkly puts that split on a shared board. Each Agent runs on one of your Computers through a Runtime, and model usage stays on your own Google account. Here’s the setup:

  1. Create the orchestrator Agent. Pick your Gemini Runtime, choose gemini-4-neon in the Agent’s Model row, and paste the sub-task template into its instructions. The Agents docs describe the Model row and its thinking-depth choice.
  2. Create one or more Hydrogen worker Agents. Same Runtime, model gemini-4-hydrogen, instructions that say “take one sub-task, meet its Done-when check, stop.”
  3. Use isolated worktrees for the workers. Each Task gets its own git worktree, so parallel runs don’t touch the original folder or each other.
  4. Let the orchestrator file sub-tasks. Agents work through the sharkly CLI, so the plan lands on the board as children of the parent Task.
  5. Mark dependencies. Use the blocks / is blocked by relation from task relations so the shared change runs first.
# The orchestrator files one sub-task per independent change
sharkly task create \
  --title "Move billing/ date formatting to formatDate" \
  --parent "$PARENT_TASK_ID" \
  --body-file subtask-billing.md
A diagram of a Gemini 4 Neon orchestrator Agent reading a parent Task, filing sub-tasks with scope and done-when checks to three Hydrogen worker Agents in separate worktrees, then running a verify pass before one human review

Set each worker’s maximum concurrency to what the Computer can carry, so extra sub-tasks queue instead of piling up. Computers in Sharkly covers how capacity and status work.

When a Hydrogen subagent fails

Workers will fail: a test won’t pass, a run times out, or the model service rejects a request. Give the orchestrator a rule for each case:

  • Check failed, scope was right: retry once on Hydrogen with the error pasted into the sub-task.
  • Check failed twice: rerun that one sub-task on Neon. In Sharkly, you can pick a model for a single run from the Assignee picker, which overrides the Agent’s default, as the task execution docs describe.
  • The plan was wrong: send it back to the orchestrator to re-split. Don’t patch around a bad decomposition.
  • Security-sensitive or architectural: escalate to Gemini 4 Carbon.

Read the execution log before any retry. A 403 or a quota error is a credentials or billing problem, and no amount of re-planning fixes it.

When not to use an orchestrator

The pattern has overhead. You pay for a plan pass and a verify pass on every Task. Skip it when:

  • the change touches one or two files, where a single Hydrogen run is cheaper;
  • the steps are strictly sequential, so there’s nothing to run in parallel;
  • the work is exploratory and the plan would be a guess.

A good rule: if you can’t name at least three sub-tasks that edit different files, don’t orchestrate.

Keep one human review at the end

The verify pass checks that the parts fit. A person still approves the merge: Google reports lower overreach for Neon, not zero, and four workers produce four times the diff. Our guide to approval gates for coding agents covers where to place that stop, and designing review for parallel agents covers why review becomes the bottleneck first.

Conclusion

A Gemini 4 Neon orchestrator works when it plans and checks, and Hydrogen does the typing. Write five-field sub-task contracts, split by file ownership, mark dependencies, and give every failure a rule. From December 1, the price gap with Carbon makes Neon the default lead for the Gemini 4 family. To try it, sign up for Sharkly, create one Neon orchestrator and two Hydrogen workers, and hand them one real four-module refactor this week. Model costs stay on your own Google bill, as BYOK on an agent platform explains.

FAQ

What is a Gemini 4 Neon orchestrator?

It’s an agent running gemini-4-neon that plans a large coding Task, splits it into scoped sub-tasks for Gemini 4 Hydrogen subagents, and verifies the combined result. Google’s launch post describes Neon as “a fast, high-judgment Orchestrator directing parallel Hydrogen subagents.”

Why use Hydrogen subagents instead of running everything on Neon?

Hydrogen costs half as much per token as Neon: $1.50 / $7.50 against $3 / $15 per 1M tokens. Most tokens in a coding run go to reading and editing files, so moving that work onto Hydrogen cuts the bill while Neon keeps the judgment calls.

Is Gemini 4 Neon cheaper than Carbon as an orchestrator?

From December 1, yes: Neon is 25% cheaper per token than Carbon, and Google reports a 32% lower cost per task at the high thinking level. Until November 30, Carbon’s introductory rate is cheaper per token.

Can I use Neon’s orchestrator mode outside Google Antigravity?

Google’s launch post describes the Orchestrator role inside Antigravity. Outside it, you build the same pattern yourself: a Neon lead Agent that files sub-tasks and Hydrogen Agents that run them, through any harness that calls the gemini-4-neon API model.

How many Hydrogen subagents should a Neon orchestrator run?

Three to five is a good start. Split by file ownership so no two sub-tasks edit the same file, then raise the count only when your Computer’s capacity and your review queue can keep up.

Does Gemini 4 Neon have a free API tier?

No. Neon is paid tier only in the Gemini API, so the orchestrator Agent needs a key from a paid project. Test that key on the Computer before the first orchestrated run.

Explore more

Agentic SDLC: The Five Pieces It Needs (Board, Agents, Review Gate)

Agentic SDLC: The Five Pieces It Needs (Board, Agents, Review Gate)

What an agentic SDLC needs in practice: a shared board, assignable agents, a separate reviewer agent, a send-back path and a human who ships. The loop step by step.

17 November 2026

Human-in-the-Loop AI Agents: What Browser Handoff Gets Right

Human-in-the-Loop AI Agents: What Browser Handoff Gets Right

Human in the loop AI agents need two kinds of checkpoint: steps only a person can do and steps a person should judge. What Browse's handoff gets right, and how to map it to a task board.

17 November 2026

AI Agent Swarms Explained: Planner, Workers and Verifiers

AI Agent Swarms Explained: Planner, Workers and Verifiers

AI agent swarms split one goal into planner, worker and verifier roles. Learn why the strong model plans and audits, where swarms fail, and how to run one.

11 November 2026

Gemini 4 Neon Orchestrator: Pair It With Hydrogen Subagents