Delegating to a Fleet
Module 2 · Delegation

Delegating to a Fleet

Decide what to run in parallel, what to hand to subagents, what to schedule as an automation, and what to keep. Learn the task traits that make parallel agents safe and the ones that make them collide.

More Agents, More Decisions

Antigravity makes it easy to start another agent. That shifts delegation from one question (“should AI do this?”) to several:

  • Should this task go to an agent at all?
  • Should it run alongside other agents, or alone?
  • Should one agent split it into subagents?
  • Should it run unattended on a schedule?
  • Should it run locally, or as a remote agent in the cloud?

Each answer adds autonomy. Each one also adds work you’ll have to review later.


The Core Test: Verifiable, Sized, Reversible

Before any parallel or unattended run, a task should pass three checks:

  1. 1 Verifiable

    Tests, types, or a visible result

  2. 2 Sized

    A diff you'll actually read

  3. 3 Reversible

    Undo is cheap if it's wrong

  • Verifiable: the agent and you can tell whether it worked, through tests, a type checker, a page that renders, or output you can compare.
  • Sized for review: the result fits your review capacity. “Rewrite the data layer” isn’t a task; it’s a project. Split it.
  • Reversible: a mistake costs a git revert, not a production outage, a sent email, or deleted data.

When Parallel Agents Work and When They Collide

Running agents in parallel works when tasks are independent:

Good parallel setWhy it works
Agent A: add tests to the billing module. Agent B: fix lint errors in reports. Agent C: draft API docs.Different files, no shared decisions, each verifiable on its own.
Bad parallel setWhy it collides
Agent A: rename the User model. Agent B: add a field to the User model.Same files, conflicting edits, a painful merge.
Agent A: design the new auth flow. Agent B: build the login page for it.B depends on A’s decisions, which don’t exist yet.

Antigravity gives subagents their own git worktrees, separate working copies on their own branches, so their file edits don’t overwrite each other while they work. Worktrees prevent agents from clobbering each other’s files. They don’t prevent logical conflicts: two branches that each work alone and break when merged. Independence is a property of the tasks, and that’s your call.

Agent A’s worktreeAgent B’s worktreeAgent C’s worktreerenames User.emailadds code using User.emailadds docs✓ passes alone✓ passes alone✓ passes alonemain, after mergingA + B together:✗ tests failWorktrees prevent file collisions. Only independent tasks prevent logical ones.
⚠️ Common Pitfall: Parallelizing Faster Than You Can Review

Common mistake: starting six agents before lunch and coming back to six large diffs, six walkthroughs, and a merge conflict.

Unreviewed work isn’t finished work. It’s a queue. If you can carefully review two agent diffs per hour, running six agents makes the queue longer, not your output higher. Start with two parallel agents. Add a third only when you’re keeping up with review.


Subagents: Let One Agent Split the Work

An agent can create subagents to handle parts of a task in parallel, for example one researching an API while another writes tests. You can see their status and message a subagent directly.

Subagents are delegation inside delegation. The same rules apply: the parts should be independent and verifiable. When you approve a permission for a conversation, Antigravity applies it to the main agent and its subagents, so a broad approval reaches further than it looks.


Automations: Delegation Without You Present

Antigravity can run automations: scheduled or always-on agent tasks. “Every weekday at 7 a.m., run the test suite against main and summarize new failures.” “Every Monday, check for dependency updates and open a summary.”

Unattended runs are the purest form of what Foundations called agency: the AI acting for you in situations you won’t see as they happen. That raises the bar:

Good automationRisky automation
Read-only reporting: test runs, dependency audits, summariesAnything that pushes, deploys, sends messages, or deletes
Output goes to you for reviewOutput goes straight to customers or production
Narrow, stable taskOpen-ended task that depends on judgment

Start every automation read-only, and only widen it after it has run correctly many times.


Local or Remote?

Remote agents run conversations in Google’s cloud rather than on your machine. Google began rolling them out to some paid plans in November 2026. A remote agent can’t touch your laptop’s files or credentials, which helps safety, but your code and context now live in a cloud environment. Check what your organization allows before sending a client’s or employer’s code there.

🧪 Try It: Build a Parallel Plan
  1. Take the task list you made in lesson 1.
  2. Mark each task: parallel-safe, sequential (depends on another), keep for myself, or automation candidate.
  3. For parallel-safe tasks, confirm they touch different files and share no undecided design choices.
  4. For automation candidates, write the read-only first version.
  5. Set your parallel limit, the number of agents whose work you can review well, and stick to it for a week.
🧠 Knowledge Check

1. Which pair of tasks is safest to run as parallel agents?

2. Subagents get their own git worktrees. What problem does that NOT solve?

3. What's the best first version of a new scheduled automation?


Up Next

You’ve decided what each agent does. Next: deciding what each agent is allowed to do, with permission presets and the sandbox.