Vibe-code AI agents that actually ship.
Describe the agent you want; let your coding agent write it. a2a init ships the SDK reference into the project, so vibe-coding produces a real @a2a.tool agent with database and API surfaces, scoped-grant support, and signed evidence on those runs. Generated code still needs review.
$ a2a init my-agent && cd my-agent# then just describe what you want, in your coding agent:› "add a skill that summarizes a PDF and saves the result"reads AGENTS.md → writes a @a2a.tool skillwires ctx.llm + the workspace backend for durable output$ a2a deploy+ https://my-agent.a2a.run · MCP + API + signed receipts
Idea to deployed, out loud
Scaffold it
a2a init drops a coding-agent-ready project — AGENTS.md, CLAUDE.md, and a build skill — so your tool already knows the SDK before you say a word.
Describe the behavior
Prompt your coding agent: 'add a skill that does X.' It writes @a2a.tool code against the real API, wiring ctx.llm and durable workspace files for you.
Deploy it
a2a deploy ships a live agent with managed Postgres, MCP and API surfaces, a frontend, and signed receipts on governed execution paths.
Vibe-coding, without the usual regrets
The scaffold turns 'fast and loose' into 'fast and governed' — the coding agent knows the rules, and the platform enforces them.
Real code, not a toy
Because the coding agent writes against the shipped SDK reference, you get working @a2a.tool skills, not a plausible-looking sketch that won't deploy.
Safe by construction
The golden rules travel with the project, so vibe-coded skills use ctx.llm, never touch provider keys, and write durable files the right way.
Governed at every entry point
Grant-backed operations use scoped authority, while Agent API, public `/invoke`, and standard MCP `tools/call` executions produce Ed25519-signed evidence.
Any coding agent
Claude Code, Codex, or Cursor — they all read the same scaffolded reference, so you vibe-code in whatever tool you think best in.
“Move at the speed of a prompt. Deploy at the standard of production.”
Before you deploy.
What does it mean to vibe-code an AI agent here?
Vibe-coding means describing what you want in natural language and letting your coding agent write it. With a2a that produces a real agent, not a throwaway: `a2a init` ships an AGENTS.md and a build skill so the coding agent knows the SDK, then you prompt it — 'add a skill that does X' — and it writes @a2a.tool code against the actual platform, ready to deploy.
Won't vibe-coded agents be insecure or throwaway?
That's the usual failure mode, and the scaffold helps by documenting the supported ctx.llm and workspace patterns. Grant-backed operations can use scoped authority, and Agent API, public `/invoke`, or standard MCP `tools/call` executions produce signed evidence. Generated code still requires review; the scaffold is not a security proof.
How fast can I go from idea to a deployed agent?
One command scaffolds a coding-agent-ready project; a few prompts turn your idea into working @a2a.tool skills; `a2a deploy` ships it with a managed Postgres, an MCP server, an API, a frontend, and signed receipts. Because the coding agent already knows the SDK, most of the time goes to describing behavior, not fighting boilerplate.
Which coding agents can I vibe-code with?
Any that read the scaffolded reference: Claude Code (via CLAUDE.md and the .claude build skill), Codex and Cursor (via AGENTS.md at the repo root). One project, one reference, whichever tool you like to think out loud in.
Describe the agent. Ship the agent.
a2a init scaffolds a coding-agent-ready project, your coding agent turns prompts into @a2a.tool skills against the real SDK, and a2a deploy ships it with managed Postgres, MCP and API surfaces, a frontend, and signed receipts on Agent API, public `/invoke`, and standard MCP `tools/call` executions.