Help us improve
Share bugs, ideas, or general feedback.
From agent-skills
Use when implementing the Agent Communication Protocol (ACP) for REST-based agent-to-agent communication, task delegation, and multimodal message exchange. USE FOR: ACP agent servers, ACP client integration, agent discovery via manifests, run lifecycle management, session-based stateful workflows, BeeAI agents DO NOT USE FOR: JSON-RPC agent communication (use a2a), tool integration for LLMs (use mcp), agent payments (use ap2 or x402), agent definition (use adl)
npx claudepluginhub tyler-r-kendrick/agent-skills --plugin agent-skillsHow this skill is triggered — by the user, by Claude, or both
Slash command
/agent-skills:acpThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
ACP is an open protocol (originally from IBM / BeeAI, now contributed to the Linux Foundation alongside A2A) for communication between AI agents, applications, and humans. It uses plain REST endpoints — no JSON-RPC, no specialized transport — making it usable with standard HTTP tools like curl, Postman, or any HTTP client.
AGENTS.mdREADME.mdmetadata.jsonrules/_sections.mdrules/_template.mdrules/acp-attach-trajectorymetadata-to-parts-when-exposing.mdrules/acp-since-acp-has-merged-into-a2a-evaluate-a2a-for-greenfield.mdrules/acp-use-get-agents-for-runtime-discovery-so-clients-can.mdrules/acp-use-redis-or-postgresql-backends-in-production-for-high.mdrules/acp-use-sessions-for-multi-turn-workflows.mdrules/acp-use-streaming-mode-for-long-running-agents-to-give-callers.mdAgent-to-Agent (A2A) protocol implementation patterns for Google ADK - exposing agents via A2A, consuming external agents, multi-agent communication, and protocol configuration. Use when building multi-agent systems, implementing A2A protocol, exposing agents as services, consuming remote agents, configuring agent cards, or when user mentions A2A, agent-to-agent, multi-agent collaboration, remote agents, or agent orchestration.
Guides developers to create new AgentCore agent projects on AWS: framework selection (Strands, LangGraph), project scaffolding, first deploy, and invocation. For beginners or 'agentcore create'.
Discovers and searches 18K+ MCP servers and AI agents across 6+ registries via Global Chat's cross-protocol directory and MCP server. Use to find tools for database access, file conversion, API integration, or agent endpoints.
Share bugs, ideas, or general feedback.
ACP is an open protocol (originally from IBM / BeeAI, now contributed to the Linux Foundation alongside A2A) for communication between AI agents, applications, and humans. It uses plain REST endpoints — no JSON-RPC, no specialized transport — making it usable with standard HTTP tools like curl, Postman, or any HTTP client.
Status: The standalone ACP repository is archived. ACP's design has been merged into the A2A project under the Linux Foundation. New projects should evaluate A2A, but existing ACP deployments and the SDK remain functional.
Every ACP agent exposes a manifest describing its capabilities — without revealing implementation details:
{
"name": "research-agent",
"description": "Finds and summarizes information on any topic",
"metadata": {
"capabilities": ["streaming", "sessions"]
}
}
Agents exchange Messages composed of Parts. Each part carries a MIME type, enabling multimodal payloads (text, images, audio, files) without protocol changes:
{
"role": "user",
"parts": [
{
"content": "Summarize this document",
"content_type": "text/plain",
"content_encoding": "plain"
},
{
"content": "<base64-data>",
"content_type": "application/pdf",
"content_encoding": "base64",
"name": "report.pdf"
}
]
}
Parts can carry structured metadata for observability and attribution:
| Method | Path | Description |
|---|---|---|
GET | /agents | List available agents with their manifests |
POST | /runs | Execute an agent (sync, async, or streaming) |
pending → running → [awaiting] → completed / error
| State | Meaning |
|---|---|
pending | Run queued, not yet started |
running | Agent is executing |
awaiting | Agent paused, requesting external input |
completed | Finished successfully |
error | Execution failed |
ACP supports three response modes on a single endpoint:
from acp_sdk.server import Server, Context
from acp_sdk.models import Message, MessagePart
server = Server()
@server.agent()
async def summarizer(input: list[Message], context: Context):
"""Summarizes the provided text."""
for message in input:
text = message.parts[0].content
yield {"thought": "Analyzing content..."}
yield Message(
role="agent/summarizer",
parts=[MessagePart(
content=f"Summary of: {text[:50]}...",
content_type="text/plain"
)]
)
server.run()
from acp_sdk.client import Client
from acp_sdk.models import Message, MessagePart
async with Client(base_url="http://localhost:8000") as client:
# Discover agents
agents = await client.agents()
# Synchronous run
run = await client.run_sync(
agent="summarizer",
input=[Message(
role="user",
parts=[MessagePart(
content="Summarize this article...",
content_type="text/plain"
)]
)]
)
print(run.output)
Sessions enable stateful, multi-turn conversations. The SDK manages session state automatically, giving agents access to complete interaction history:
async with Client(base_url="http://localhost:8000") as client:
# First turn — creates a session
run1 = await client.run_sync(
agent="assistant",
input=[Message(role="user", parts=[
MessagePart(content="My name is Alice", content_type="text/plain")
])]
)
# Second turn — continues the session
run2 = await client.run_sync(
agent="assistant",
session=run1.session_id,
input=[Message(role="user", parts=[
MessagePart(content="What is my name?", content_type="text/plain")
])]
)
For production deployments, ACP supports centralized storage backends:
| Aspect | ACP | A2A | MCP |
|---|---|---|---|
| Transport | REST (HTTP) | HTTP + JSON-RPC + SSE | stdio, HTTP + SSE |
| Discovery | GET /agents | Agent Cards (.well-known/agent.json) | Capabilities negotiation |
| Interaction | Runs (sync/async/stream) | Tasks (long-running) | Request-response (tool calls) |
| Focus | Agent-to-agent + human-to-agent | Agent-to-agent delegation | Agent-to-tool integration |
| Multimodal | MIME-typed parts | Typed parts | Tool arguments |
| Sessions | Built-in stateful sessions | Task context | Conversation context |
| Language | Server | Client |
|---|---|---|
| Python | acp-sdk | acp-sdk |
| TypeScript | — | acp-sdk |
# Python
pip install acp-sdk
# TypeScript
npm install acp-sdk
GET /agents for runtime discovery so clients can dynamically route to the right agent without hardcoding endpoints.TrajectoryMetadata to parts when exposing reasoning steps for observability.