◉ANTIGRAVITY LABJP
Articles/Antigravity Basics
◉ Antigravity Basics/2026-11-16Intermediate

Choosing Between Orchestrator, /swarm, and /run-workflow by the Shape of the Work

Orchestrator, /swarm, and /run-workflow all landed in Antigravity within one week of November 2026. Instead of picking by model strength, I pick by the shape of the task: is there one decision that spans everything, are the items independent, do the workers need to talk mid-task? Here are those three questions, plus what I check in a workflow script before approving it.

antigravity476orchestratorswarmdynamic-workflowssubagentsdesign15

In the second week of November, Orchestrator showed up in Antigravity's model picker, and /swarm and /run-workflow joined the slash commands. That weekend I sat down to hand off some work on my wallpaper app and found my hands hovering over the prompt box. A normal conversation, a team, or a script? With three new options at once, every one of them looked right.

What I've come to think is this: you don't choose among these by model strength. You choose by the shape of the work. The official docs do include a comparison table, but reading it didn't tell me which row my actual task belonged to. So these are the three questions I now use to place a task.

What each one actually splits

Here's what I confirmed in the official documentation (as of November 16, 2026, App v2.32.0).

  • Orchestrator is an entry in the model picker. Inside a single conversation, a planner model (Gemini 4 Carbon or Gemini 4 Argon) plans in a read-only phase, and Gemini 4 Hydrogen does the implementation. If Hydrogen hits friction, control goes back to the planner, which repairs the plan before work resumes. What it splits is the model; the conversation stays as one.
  • /run-workflow (Dynamic Workflows) has the agent write a short Python script, and that script runs many agents with parallel() or pipeline(). The agents don't know about each other; each returns a result that matches a JSON Schema. What it splits is the items.
  • /swarm turns your current conversation into a coordinator that assigns work to named workers such as @parser. Workers talk on a shared board with @name mentions, and there is usually one @verifier for every two to four workers to read diffs and run tests. What it splits is ownership, and the owners can talk to each other.

The Antigravity blog reports that on Terminal-Bench 4.1, Orchestrator reached near-Carbon task success while using 24% less quota and finishing 19% faster on average. Those are the vendor's benchmark numbers, not something I measured myself.

Plans differ too. /swarm and /run-workflow are on Google AI Pro and Ultra; Orchestrator (Carbon) is Ultra only, and Orchestrator (Argon) is also available on Pro. /swarm is in preview, and the docs say plainly that because every worker is its own agent, a swarm uses quota much faster than a single conversation.

My first instinct was to parallelize everything

I tested these against a job I'd already done as an indie developer: a full localization audit of my wallpaper app. For each supported language, check the store description and the in-app strings. Same check, repeated per language. It looked like a textbook parallel job, so I started drafting a /swarm prompt with one worker per language.

Halfway through writing it, I noticed the audit actually contained two different kinds of work. Some checks were independent per language — missing translations, length limits, broken links. Others were decisions that cut across every language — where to unify the device-language detection, and what to do with mismatches I'd left in on purpose. Those only need to be decided once. Give them to separate owners per language and you just get different answers.

Looking back, the confusion wasn't caused by having too many tools. It came from not breaking the task apart before reaching for parallelism.

Three questions I ask before going parallel

Before handing anything off, I now ask myself these in order.

  1. Is there a decision in this task that exists only once, for the whole thing? If so, settle it first in a single conversation. If the decision needs strong planning, use Orchestrator or the planner model on its own.
  2. Can the remaining items finish without seeing each other's results? If yes, that's /run-workflow: one review per file, one audit per package, one check per language.
  3. Do the owners need to talk while they work? Agreeing on an interface, reviewing each other's diffs — if that kind of coordination happens mid-task, that's /swarm. The docs say the same: if agents need to coordinate while they work, use /swarm instead of a workflow.

If all three answers are no, a normal single conversation is usually the fastest path. And if you just want to hand off one research question or a build while you keep working, delegating to a subagent is enough.

Applied to the localization audit, the job became two steps: decide the language-detection approach in one conversation, then pass only the per-language checks to /run-workflow. /swarm never came into it.

One-time decisions go in a conversation, independent items go in a script, and only owners who need to talk get a team. However many new modes arrive, that's the order I'd rather keep.

What I read in a workflow script before approving it

With /run-workflow, Antigravity shows you the generated Python script and asks for approval before it runs (unless a permission preset such as Turbo already allows it). You don't need to write Python to review it; you just need to know where to look. For the per-language check, the script looks something like this:

phase("Discover")
locales = await agent(
    "List the locale folders under fastlane/metadata. Folder names only.",
    schema={"type": "array", "items": {"type": "string"}},
)
 
phase("Check")
# Locales don't depend on each other, so parallel() is fine.
# Read only. Any edits get decided by a human in a separate conversation.
results = await parallel(
    locales,
    lambda loc: agent(
        f"Read fastlane/metadata/{loc}. Report missing translations, "
        "fields over the store length limit, and broken links. Do not edit files.",
        schema={"type": "string"},
        role=f"Check {loc}",
        model="flash",
    ),
)
for r in results:
    log(r)

Three things I check before saying yes:

  • parallel() or pipeline()? With parallel(), if one item fails, the rest are canceled. If the work touches shared files or a shared test suite, I ask for pipeline(), which processes one item at a time.
  • Does the prompt say "Do not edit files"? A read-only check shouldn't get write access. When agents do need to edit, I ask for workspace set to branch so each one gets its own Git worktree.
  • What's the model? Without it, agents inherit the conversation's model. For a high-volume, lightweight check, I ask for flash so a heavy planner model isn't running on every item.

If something feels off, choose No and tell the agent what to change; it rewrites the script. Once a script works, have it saved as a .py file in the project so you can rerun it later with something like /run-workflow Run scripts/check-locales.py.

Two things I decide before starting a /swarm

I only use /swarm when the owners genuinely need to talk. Even then, I add two things to the prompt.

The first is what "done" means. The coordinator posts each worker's brief — what it owns, what it must not touch, what done looks like — to the board, but that brief comes from how I asked. If I don't spell out the test command or the check, the verifier has nothing concrete to verify.

The second is what happens when quota runs out. Per the docs, a member that runs out of quota pauses instead of retrying, and it doesn't restart on its own when quota refreshes. Start a swarm at night and you may find it stalled halfway in the morning, so for long jobs I check status at natural break points.

I've written about where adding agents stops helping in "Areas where more agents don't make you faster", and about verification gaps in isolated worktrees in "When /boost says 'verified'".

Instead of a summary

The week new options arrive is exactly the week you want to try all of them, and that's worth honoring. Still, I'd suggest picking the next task you plan to hand off and splitting it on paper into three piles: one-time decisions, independent items, and owners who need to talk. You may find, as I did, that more of it fits in a single conversation than you expected — and that was a real weight off for me.

Share

Thank You for Reading

Antigravity Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

  • ✦Copy-paste ready implementation code
  • ✦New advanced guides published daily
  • ✦$5/mo or $10 for lifetime access
View Membership →

If you found this article helpful, a small tip ($1.50) would mean a lot to us. Your support helps keep this site ad-free and covers server and hosting costs.

Related Articles

◉ Antigravity2026-10-24
The File Is Right There, but Linux Says "No Such File" — Check the Interpreter, Not the Path
When agy's grep search fails on Linux and the log says "no such file or directory" for a file that clearly exists, the culprit is the ELF interpreter. Here is how to confirm it, reproduce it, and work around it for now.
◉ Antigravity2026-10-20
NoClassDefFoundError on Old Android Devices Only — Four Clues I Gather Before Handing It to an Agent
Everything works on new phones, but Android 6 devices crash. Using a Supplier NoClassDefFoundError that appeared after a Glide update, this note covers the order of diagnosis, the coreLibraryDesugaring setup, and what to prepare before asking an agent to investigate.
◉ Antigravity2026-10-17
Build the Environment Note Before You Write the Question — A Small Shell Script for Posts That Get Replies
A small shell script that gathers your OS, tool versions, and the tail of a log into one note you can paste into a forum post or issue, with secrets masked. Here is what it catches, what it misses, and the three lines only you can write.