Have a project in mind? Let's talk.

Antigravity Dynamic Workflows landed in Google's agentic IDE this week, and they change one specific thing that has been awkward since multi-agent coding tools appeared: fan-out work is no longer a long, rambling conversation. With the /run-workflow command, the agent writes a short Python script that starts and coordinates other agents for you, collects a structured result from each, and keeps the whole operation out of your main chat's context. This post walks through what the feature actually does, the primitives and knobs that matter, the parallel() failure mode you should know about before running it on 40 files, and how to choose between Dynamic Workflows, /swarm, /teamwork, subagents, and Orchestrator.
You type /run-workflow plus a task, for example "review every Python file changed since main." The agent reads its built-in run-workflow skill and generates a Python script for your task. It shows you the script and asks you to approve it, unless your permission preset already allows it, and then the workflow runs in the background in a separate Python process. When it finishes, the main agent reads the logs and output and summarizes the results in your conversation. Dynamic Workflows are available on Google AI Pro and Google AI Ultra plans, in both the Antigravity App and the Antigravity CLI, and Antigravity bundles its own Python so you do not need to install one. Source: Dynamic Workflows (/run-workflow), Google Antigravity Docs
The script itself uses a small set of primitives. phase(name) groups work into named stages you can follow live, agent() starts a one-shot or multi-turn agent, parallel(items, fn) fans work out concurrently, pipeline(items, fn) runs items one at a time, log() emits output lines, and await trajectory() lets the script read earlier steps of the conversation that existed before the workflow started. An args dictionary carries runtime inputs. Source: Dynamic Workflows (/run-workflow), Google Antigravity Docs
Each agent a workflow starts works in its own conversation. File reads, searches, and test logs stay out of your main conversation's context, and results come back through a finish mechanism that validates each agent's answer against the JSON Schema you passed to agent(). The script receives a parsed value, not prose you have to pick apart. One of the first practitioner write-ups, published the day the docs went live, called this the quiet headline: fan-out work stops paying the context tax on the thread you are actually sitting in. Source: Antigravity's /run-workflow writes the Python that runs your agent fleet, DEV Community
The same isolation cuts the other way, and the docs are blunt about it: workflow agents cannot see the orchestration script and cannot see each other. The script must give each agent everything it needs in its prompt and ask for a short, well-defined result. If your reviewers need the coding standard, the script pastes it in or names the file. Implicit context does not travel, which means stale or missing instructions hurt more here than in a single conversation. Source: Dynamic Workflows (/run-workflow), Google Antigravity Docs
There is one sentence in the design worth memorizing before you fan out across a whole repository: in parallel(), if one item fails, the others are canceled. On a 40-file review where one agent trips, the 39 in-flight results die with it. The documentation describes no retry and no partial-result mode for that case, so the practical guidance from early users is to treat a failed item as a whole-phase retry, keep phases small, and reach for pipeline() when ordering matters more than speed. Source: Antigravity's /run-workflow writes the Python that runs your agent fleet, DEV Community
Three knobs do most of the tuning work. model defaults to inherit, and the docs suggest flash_lite or flash for fast, high-volume checks across many files, or pro for deeper reasoning. workspace can be inherit, branch, or share: branch gives each agent an isolated Git worktree, which is the right call when agents edit code in parallel. type_name picks the agent type: self, the built-in read-only research agent, or a custom subagent you have defined. Multi-turn agents are the subtle option: assign one to a variable, and the same reviewer that found the bugs can later confirm they are fixed. Source: Dynamic Workflows (/run-workflow), Google Antigravity Docs
The docs themselves publish a decision table, and it is the clearest part of the launch. Use Orchestrator when you want a single conversation where a frontier planner model plans and reviews while routing routine tool execution to a smaller model. Use subagents to delegate one task while you keep working. Use Dynamic Workflows for predictable, scripted control flow: the same check across a list of files or packages, staged steps in sequence, or a reviewer-and-fixer loop where agents return structured results to a script instead of talking to each other. Use /swarm when peers need to collaborate on a shared message board, for example to agree on interfaces or review each other's diffs. Use /boost for deep reasoning on one hard bug, and /teamwork for a large, multi-milestone project that starts with a scoping interview. Source: Dynamic Workflows (/run-workflow), Google Antigravity Docs
The dividing line that matters most in practice: if your agents need to coordinate with each other while they work, use /swarm instead of a workflow. Workflows are for fan-out where each piece is independent; swarms are for problems where the pieces must talk. We covered the teamwork side of this lineup in our post on Antigravity's teamwork agent teams, and the broader pattern of splitting work across specialized agents maps onto what we wrote about async subagents.
The documentation ships example prompts that show the intended shape of a workflow task. "Review changed files in parallel" fans one reviewer across every file touched since main. "Review, fix in parallel, and verify" chains a reviewer and a fixer per file, then re-checks. "Edit in isolated workspaces" pairs parallel editing with branch workspaces so agents never collide on the same working tree, and "Test, then fix, one item at a time" uses pipeline() for an ordered loop where each fix depends on the previous test result. Read them once before writing your own, because they encode the two habits that make workflows reliable: small independent items, and explicit stages. Source: Dynamic Workflows (/run-workflow), Google Antigravity Docs
The design choices here read like a preview of where agent orchestration is heading across the industry. Scripted control flow instead of conversation-length coordination. Structured, schema-validated results instead of free-text handoffs. Context isolation as a first-class concern rather than an afterthought. And a reviewable artifact, the Python script itself, that you can approve, save to your project, and run again later. For teams building their own agent systems, /run-workflow is a working reference implementation of orchestration patterns you would otherwise have to assemble from frameworks, and the failure-mode honesty in the docs (no retries on parallel() cancellation, agents blind to each other) is a useful checklist for your own designs.
Our read: Dynamic Workflows is the most consequential Antigravity addition since /teamwork, because it converts the messiest part of multi-agent work, coordination, into something inspectable and reusable. The limitation that will bite teams first is not the parallel() cancellation, it is the context blindness: every piece of knowledge an agent needs must be written into the script's prompts, and teams with sloppy internal documentation will feel that immediately. Start with read-only fan-out jobs like reviews and audits, keep phases under a dozen items, save the scripts that work, and only then move to parallel editing with branch workspaces.
It is the command behind Antigravity Dynamic Workflows. You describe a task, the agent writes a short Python script that starts and coordinates other agents in parallel or in sequence, collects schema-validated results, and summarizes everything back in your main conversation.
According to Google's documentation, Dynamic Workflows are available on Google AI Pro and Google AI Ultra plans, in both the Antigravity App and the Antigravity CLI.
The other in-flight items are canceled. The docs describe no retry and no partial-result mode, so keep phases small and treat a failed item as a whole-phase retry, or use pipeline() when ordering matters more than speed.
Use /swarm when your agents need to coordinate with each other while they work, for example to agree on interfaces or review each other's changes on a shared message board. Workflows are for independent fan-out; swarms are for interdependent collaboration.
No. Each workflow agent runs in its own conversation and sees neither the orchestration script nor the other agents. Everything an agent needs must be passed explicitly in its prompt, and its result must be short and match the JSON Schema you declared.
Ready to take the first step towards unlocking opportunities, realizing goals, and embracing innovation? We're here and eager to connect.