Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add OneWave-AI/claude-skills --skill agent-to-agent -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/agent-to-agent/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/agent-to-agent/

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

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set185

The whole set →
client-health-dashboard client-health-dashboard builds a client health view from CRM and engagement data, then produces a risk-ranked report with scores, trends, and next actions. CX Codex +1 276installs hiring-scorecard Builds a structured hiring scorecard for any role with weighted competencies, interview questions, evaluation matrix, red/green flags, and reference check questions. CX Codex +1 268installs sub-agent-orchestrator sub-agent-orchestrator chains different agents so each step feeds the next, with the flow defined in YAML. Handles retries, timeouts and parallel branches. CX Codex +1 267installs database-migrator database-migrator moves schemas, data, and database logic across PostgreSQL, MySQL, Supabase, PlanetScale, and MongoDB. Useful when a migration needs checks and a rollback plan. CX Codex +1 267installs pricing-strategy Builds a pricing strategy for a product or service: analyzes costs, researches competitors, selects a model (cost-plus, value-based, penetration, premium), designs tier structure, projects revenue. CX Codex +1 260installs ai-readiness-assessment ai-readiness-assessment evaluates business readiness for AI adoption across six dimensions and generates an ai-readiness-report.md document with gap analysis. CX Codex +1 260installs api-load-tester api-load-tester — a skill for Claude Code, Codex, Cursor and other platforms that stress-tests HTTP endpoints with progressive concurrency. CX Codex +1 260installs gmail-to-crm-pipeline gmail-to-crm-pipeline reads unread Gmail inquiries, scores each lead against your ICP, and writes qualified ones into Supabase. Replies stay as drafts. CX Codex +1 260installs

Project sponsors

Companies that keep this analytics open