agent-to-agent — Claude Code skill: what it does, how to install
agent-to-agent coordinates multi-agent workflows across Claude agents using shared context files, structured handoffs, and predefined orchestration patterns.
MIT 263 installs ★ 440 updated 2026-10-20
npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a claude-codeWhat agent-to-agent does
This skill sets up the Agent-to-Agent (A2A) protocol layer. Claude Code acts as a coordinator that designs the team, picks an interaction model like pipeline, fan-out/fan-in, or supervisor, and dispatches sub-agents using the native Agent tool.
All state transitions, task statuses, and shared memories go directly into .a2a-context.json at the project root. The protocol enforces atomic read-modify-write cycles where workers write solely to their own blocks or the shared conclusions segment. Reassigning tasks remains restricted to the coordinator. Once .a2a-context.json crosses 50KB, the skill triggers context summarization.
Secrets must never hit the JSON store; sensitive parameters pass strictly in-memory inside sub-agent prompts. The coordinator monitors progress, caps automatic retries at 3 on failures, and escalates directly to the user if recovery stalls.
What it helps with
- run multi-agent research and drafting pipelines with structured handoffs
- distribute independent subtasks across parallel agents via fan-out
- maintain shared project state across disparate agent executions
- handle deadlocks, rejections, and execution timeouts with fixed retries
Example prompts for the agent
- Set up an A2A pipeline with a researcher and a writer to draft an analysis report
- Coordinate a code-and-review workflow using the supervisor pattern in .a2a-context.json
- Initialize the A2A coordinator to delegate parallel audit tasks
How to install agent-to-agent
1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a claude-code2Manually: put the files in place
~/.claude/skills/agent-to-agent/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/agent-to-agent/
1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a codex2Manually: put the files in place
.agents/skills/agent-to-agent/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a cursor2Manually: put the files in place
.cursor/skills/agent-to-agent/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install OneWave-AI/claude-skills agent-to-agent2Manually: put the files in place
.github/skills/agent-to-agent/SKILL.md1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a gemini-cli2Platform CLI
gemini skills install https://github.com/OneWave-AI/claude-skills --path agent-to-agentManually: put the files in place
.devin/skills/agent-to-agent/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about agent-to-agent
How to install agent-to-agent in Claude Code?
Run npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a claude-code. It places the skill file into ~/.claude/skills/agent-to-agent/SKILL.md.
What does agent-to-agent do?
It orchestrates multi-agent collaboration by standardizing message exchanges, tracking task chains, and syncing context through a shared JSON file.
How does the protocol manage sensitive credentials?
Sensitive values must never be written to .a2a-context.json; the coordinator passes them in-memory via agent prompts, and the state file belongs in .gitignore.
Source text
SKILL.md · MIT
--- name: agent-to-agent description: Agent-to-Agent (A2A) communication protocol. Connect two or more Claude agents that pass messages, share context, delegate tasks, and collaborate. Implements structured handoffs, shared memory, and multi-agent conversations. tools: Read, Write, Agent, Bash, Glob, Grep model: inherit --- # Agent-to-Agent (A2A) Communication Protocol Act as the A2A Coordinator: a protocol layer that lets multiple Claude Code agents communicate, collaborate, and delegate work through structured message passing, shared context, and formal handoffs. Orchestrate every interaction through the shared context file `.a2a-context.json` and the Agent tool. ## Contents - `references/protocol.md` — message format, message types, lifecycle, shared context schema, atomic read-modify-write, context size management. - `references/registry.md` — agent registration, capability discovery, built-in agent templates. - `references/patterns.md` — request/response, pipeline, fan-out/fan-in, conversation, supervisor. - `references/handoff.md` — structured handoff, acceptance, rejection, chain tracking. - `references/error-handling.md` — timeouts, rejections, deadlock detection, degradation, escalation matrix. - `references/workflows.md` — worked examples (research+writer, code+review, sales+technical). - `references/operations.md` — coordination commands, best practices, monitoring, security, init detail. ## Workflow 1. Understand the goal. Determine what the user wants to accomplish with multiple agents. 2. Design the team. Decide which agents are needed; draw from the templates in `references/registry.md` or write custom specs. 3. Choose the pattern. Select pipeline, fan-out/fan-in, conversation, or supervisor from `references/patterns.md`. Prefer pipeline when order matters, fan-out when subtasks are independent. 4. Initialize. Locate the project root. Read `.a2a-context.json` if it exists and report current state; otherwise create it from the template in `references/operations.md`. Register every agent into the `agents` section per `references/registry.md`. 5. Execute. Dispatch agents via the Agent tool following the chosen pattern. Structure each agent prompt with identity, context, task, output location, protocol, and constraints (see `references/operations.md`). For parallelism, issue multiple Agent tool calls in a single response. 6. Coordinate handoffs. When an agent transfers a task, require a full handoff payload and an ACK, and append to the task `chain`. Follow `references/handoff.md`. 7. Monitor and recover. Read `.a2a-context.json` to track progress. On timeout, rejection, deadlock, or failure, apply the procedures and escalation matrix in `references/error-handling.md`. Cap retries at 3 before escalating to the user. 8. Deliver. Merge all agent findings into the `conclusions` section and present the final output. ## Core Rules - Treat `.a2a-context.json` as the single source of truth. Read it before acting; write the complete file back after modifying. Follow the atomic read-modify-write procedure in `references/protocol.md`. - Conform every inter-agent message to the schema in `references/protocol.md`. - Confine each agent to writing its own section plus shared `conclusions`. Restrict task assignment changes to the Coordinator. - Never write secrets to `.a2a-context.json`; pass sensitive data in-memory through Agent prompts and add the file to `.gitignore`. - Require explicit ERROR messages for all failures; never fail silently. Run context summarization when the file exceeds 50KB. ## Minimal Example: 2-Agent Pipeline ``` User: "Research the top 5 AI frameworks and write a comparison article." Coordinator: 1. Create .a2a-context.json 2. Register: researcher, writer 3. Dispatch researcher: "Search for top 5 AI frameworks, compare features, performance, ecosystem" 4. Read researcher's findings from shared context 5. Dispatch writer: "Using the research findings, write a 1200-word comparison article" 6. Read writer's draft from shared context 7. Present the final article to the user ```
© OneWave-AI · MIT · OneWave-AI/claude-skills