Google Antigravity Ships Dynamic Workflows to Run Parallel AI Coding Agents

Google Antigravity has introduced Dynamic Workflows, a way to coordinate multi-agent coding tasks through generated Python scripts. The /run-workflow command turns a request into a reviewable program with named phases, parallel or sequential execution, structured outputs, and a flow that developers can save and run again. This makes repeated reviews, package-level audits, and test-then-fix jobs easier to inspect and reproduce.

Python takes the coordinator’s seat

1. The main agent loads Antigravity’s built-in workflow skill and generates a Python script for the requested task.
2. Antigravity displays the script and waits for approval before executing it.
3. A separate Python process runs the workflow in the background while the original conversation remains available.
4. When execution finishes, the main agent reads the logs and summarizes the results.

Each workflow-launched agent receives its own conversation and cannot see the orchestration script or its peers. The script must therefore supply every agent with the required context, task, and output format. This isolation supports independent work such as reviewing each changed file or testing separate packages.

Structured returns keep the parent workflow predictable. A subagent submits its result through the finish tool, which validates the value against a specified JSON Schema before passing the parsed result to the script. File reads, searches, and test output remain in the subagent conversations, preserving the main conversation’s context window during high-volume jobs.

Five primitives define the flow

The generated program uses a small asynchronous API that covers logging, agent creation, concurrency, sequencing, and access to earlier conversation steps:

• phase(name) starts a named phase and groups its logs and agent cards.
• agent(prompt, schema, role, model, workspace) defines an agent. Awaiting it produces a single result; retaining its handle supports subsequent turns with the same agent.
• parallel(items, fn) runs fn(item) concurrently for every item and preserves result order. If one operation fails, Antigravity cancels the remaining operations.
• pipeline(items, fn) processes items sequentially.
• await trajectory(...) makes selected earlier steps from the parent conversation available to the script.

A generated workflow for parallel exception reviews could look like this:

phase("Discover")
files = await agent(
    "List the Python files changed since main. Paths only.",
    schema={"type": "array", "items": {"type": "string"}},
)

phase("Review")
reviews = await parallel(
    files,
    lambda f: agent(
        f"Review {f} for unhandled exceptions. One-line verdict.",
        schema={"type": "string"},
        role=f"Review {f}",
        model="flash",
    ),
)

Per-agent controls let developers match cost and capability to each step. High-volume checks can use flash_lite or flash, while tasks requiring deeper reasoning can use pro. A workflow may also select Antigravity’s read-only research agent or a custom subagent.

Parallel editing jobs can assign workspace="branch" to each agent, giving every worker an isolated Git worktree. Agents can then modify files and run tests concurrently without overwriting one another’s changes.

Choose by communication pattern

Antigravity provides three multi-agent options, with the task’s coordination pattern determining the appropriate tool:

Jobs suited to /run-workflow

1. Run the same lint-style review across every file changed on a branch.
2. Have a persistent reviewer identify bugs, dispatch parallel fixers, and verify the resulting changes.
3. Refactor packages in isolated Git worktrees and run each package’s tests.
4. Process a bug queue sequentially, creating a failing test before implementing each fix.

Plans, credits, and runtime

Dynamic Workflows are available with Google AI Pro and Google AI Ultra in the Google Antigravity App and Antigravity CLI. They have no separate price and consume the plan’s existing model credits. High-fanout workflows can trigger many model calls, so model selection provides the main control over credit use.

The workflow runs in a separate process using the Python runtime bundled with Antigravity, so no local Python installation is required. Developers who need a different interpreter can set the ANTIGRAVITY_PYTHON environment variable.

Saving the generated program as a .py file in the workspace makes the same orchestration available for later runs. Teams can review that script alongside their code and reuse it for recurring audits, refactors, and test workflows.