The developer inner loop for AI agents.
Building an agent is edit-test-iterate, and the speed of that loop is the whole game. `a2a dev` watches your files: each save re-syncs and hot-reloads the agent in about two seconds, locally or on a scale-to-zero cloud dev box with a public URL. You drive it from the /_dev console or the live URL, then edit again. No build, no redeploy, no waiting on CI — that's the outer loop.
save · reload ~2s · re-invoke · repeat
Redeploying to test an edit kills the loop.
If the only way to see a change is to rebuild an image, push it, and wait on a pipeline, then every experiment costs a full outer-loop cycle. You batch edits to avoid the wait, lose the thread between change and effect, and end up debugging against a mock that behaves unlike production. The loop that matters — edit, see it, edit again — never gets tight, and iteration speed collapses under CI latency.
The inner loop is live-reload, not a CI cycle.
`a2a dev` watches your files and hot-reloads the running agent in about two seconds on each save — no build, no redeploy. Re-invoke tools from the /_dev console, run against local Postgres and Qdrant, and stay on the same runtime you'll deploy to. Deploy is the outer loop, done once the change is right.
Save, reload in ~2s
`a2a dev` watches your files. Each save re-syncs the agent and hot-reloads it in about two seconds. You edit a tool, hit save, and the next invocation runs the new code — no build step, no restart you drive by hand.
No redeploy per change
The inner loop is live-reload, not a CI cycle. You aren't packaging an image, pushing to a registry, and waiting on a pipeline for every tweak. Deploy is the outer loop — separate, and something you do when the change is done, not to test it.
Drive it from /_dev
After each reload the /_dev console lets you re-invoke tools directly — same inputs, new code — so you see the effect of an edit immediately. The agent card at /.well-known/agent-card shows what the agent currently advertises as you change it.
Local or on a cloud dev box
Run the loop on your machine, or on a scale-to-zero cloud dev box with a public URL — same `a2a dev`, same hot-reload. When you need a real URL to hit from a webhook or a phone, the loop follows you there without changing.
Same runtime as production
The agent in the loop runs on the same runtime it will run on in production. A fast loop is only useful if it reflects real behavior — parity means what you see reloading is what you get deployed, not an approximation you re-debug later.
Loop against real data
`a2a chat` brings up local Postgres and Qdrant so the loop runs against real data, not mocks. You iterate on a tool that reads and writes the actual store, so the feedback is about how the agent behaves, not how your fixtures behave.
Redeploy-per-change outer loop vs. the ~2s inner loop.
Frequently asked.
What is the inner loop for AI agents?
The inner loop is the tight edit-test-iterate cycle you run while building an agent: change a tool, see it run, change it again. With `a2a dev` that loop is live-reload — each save re-syncs and hot-reloads the agent in about two seconds, so you're driving the new code almost immediately. The outer loop — package, deploy, roll out — is separate, and you don't pay it to test a change.
How fast is the a2a dev feedback loop?
About two seconds from save to reload. `a2a dev` watches your files, re-syncs on each change, and hot-reloads the running agent — locally or on a scale-to-zero cloud dev box. There's no rebuild and no redeploy in the loop, so the wait per edit is the reload, not a CI pipeline.
Do I have to redeploy to test a change?
No. Redeploy is the outer loop. In the inner loop you save a file and the agent hot-reloads in place — no image build, no registry push, no rollout to wait on. You deploy when the change is done and you want it live, not to check whether it works.
How do I re-run a tool after each reload?
Use the /_dev console. After each hot-reload it lets you re-invoke the agent's tools directly with the same inputs, so you can see the effect of an edit immediately. The agent card at /.well-known/agent-card shows what the agent currently advertises, which updates as you change its tools.
Does the fast loop still reflect real behavior?
Yes — the agent in the loop runs on the same runtime it runs on in production, so the loop reflects real behavior rather than an approximation. And `a2a chat` brings up local Postgres and Qdrant, so you iterate against real data, not mocks. A fast loop is only worth having if what you see reloading is what you get deployed.
Related guides.
All guides live in the guides index.
Keep the loop tight; save deploy for when it's done.
a2a cloud gives any agent — LangGraph, OpenAI Agents SDK, CrewAI, or custom — a fast inner loop: `a2a dev` hot-reloads on save in about two seconds, the /_dev console re-invokes tools, and the agent card lives at /.well-known/agent-card. Run it locally or on a scale-to-zero cloud dev box with a public URL, against local Postgres and Qdrant, on the same runtime you deploy to. Deploy is the outer loop — one command when the change is right.