Inside Google Antigravity Dynamic Workflows: Python Asyncio Primitives, Worktrees & Fail-Fast Concurrency

When Google introduced Antigravity 2.0, the biggest architectural shift for backend engineers was the transition away from static Markdown instructions toward executable orchestration scripts via /run-workflow.

Instead of relying on prompt chains that accumulate conversational dead weight, Google Antigravity Dynamic Workflows compile orchestration logic into asynchronous Python code. The runtime spins up parallel subagents in isolated sandboxes, enforces strict JSON Schema contracts, and uses native asyncio event loops for fail-fast error recovery.

To see the concurrent execution loop in action in under 60 seconds, watch my video breakdown below:

https://www.youtube.com/shorts/vpIIwVZQnjI

---

1. The Architectural Problem: Conversational Drift in Agent Loops

When an LLM attempts to execute iterative engineering tasks across dozens of files inside a single chat window, three systemic issues emerge:

1. Context Bloat: Accumulating source files and terminal stderr dumps degrades attention mechanisms, leading to hallucinated imports and forgotten constraints.
2. Heuristic Loops: Natural language prompts like "review all 20 files in src/" are probabilistic. LLMs frequently skip files or terminate prematurely without completion guarantees.
3. Cascading Failure Modes: When a sub-task fails in a prompt chain, the agent often proceeds blindly, compounding errors across downstream dependencies.

Dynamic workflows resolve this by decoupling the planner from the workers. The lead model authors an asynchronous Python script that coordinates execution with deterministic state control.

Traditional Prompt Chaining ❌
User Chat ──► 20 Files Read ──► Massive Token Bloat ──► Prompt Drift & Broken Code

Antigravity Dynamic Workflows ✅
User Chat ──► Writes Python Script ──► Parallel Worker Agents ──► Clean Summary in Chat

---

2. Core Python Asyncio Primitives

Antigravity executes dynamic workflow scripts in a dedicated Python 3.8+ environment. The platform injects several powerful orchestration primitives:

# Real example of a Dynamic Workflow script in Antigravity
phase("Discover")
modules = await agent(
    "List all Python module paths (.py files) in src/inventory. "
    "Only inspect file paths. Return relative paths sorted alphabetically.",
    schema={"type": "array", "items": {"type": "string"}},
    role="Discover Inventory Modules"
)

phase("Review")
reviews = await parallel(modules, lambda mod: agent(
    f"Inspect {mod} for unhandled database exceptions. Return a 1-line verdict.",
    schema={"type": "string"},
    role=f"Audit {mod}",
    workspace="branch",
    model="flash"
))

for r in reviews:
    log(r)

Breakdown of Primitives:

• phase(name): Visual milestone markers. In both the Antigravity desktop IDE and CLI (agy), phases group logs and agent cards so developers can monitor execution stages in real time.
• agent(prompt, schema, role, workspace, model): Constructs a lazy helper agent. It does not spawn until awaited or passed into an execution runner. Pinned to lightweight tiers like model="flash" to optimize token consumption.
• schema (Strict JSON Contracts): Forces the worker agent to terminate by calling its internal finish tool with structured arguments. Unstructured text responses are rejected.
• parallel(items, fn): Maps concurrent async tasks across items. Crucially, if any worker throws an unhandled exception or fails schema validation, all sibling workers are cancelled immediately via asyncio task cancellation.
• workspace="branch": Automatically provisions isolated Git worktrees for each subagent. Workers can modify files, execute linters, and stage commits concurrently without git lock collisions.

---

3. Dynamic Workflows vs. Swarm vs. Subagents

Antigravity provides three distinct multi-agent paradigms depending on execution shape:

Evaluation Metric	Dynamic Workflows (/run-workflow)	Native Swarm (/swarm)	Standard Subagents (invoke_subagent)
Coordination Model	Deterministic Python script	Shared Message Board (@mentions)	Direct parent-child invocation
Communication	Structured JSON returned to Python	Multi-agent debate and handoffs	Return string or tool output
Failure Handling	Fail-fast cancellation across workers	Stall monitor reassignments	Error returned to caller
Token Efficiency	Very high (Flash workers)	Higher (workers read board posts)	Low (isolated execution)
Primary Use Case	Codebase audits, batch refactoring, test suites	Multi-role specialist teams	Single browser test, graphic design

---

4. Script Persistence and CLI Automation

Unlike ephemeral chat prompts, dynamic workflow scripts can be saved directly into your repository as permanent automation assets:

# Running a saved, parameterized dynamic workflow via the Antigravity CLI
agy /run-workflow --file ./workflows/security_audit.py --args '{"target_dir": "src/auth"}'

This transforms dynamic workflows from a conversational assistant feature into a deterministic CI/CD and developer tooling platform.

For a full breakdown of the 4-stage pipeline, bookstore audit benchmarks, and security approval gates, read my complete guide on Google Antigravity Dynamic Workflows at SoftReviewed.