> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stackone.com/llms.txt
> Use this file to discover all available pages before exploring further.
# StackOne A2A Agents
> Connect to agents built for StackOne platform actions in code or multi-agent systems via the Agent2Agent (A2A) Protocol.
**Open Beta Feature**: StackOne A2A agents are currently in open beta. While fully functional, the API and features may evolve based on user feedback.
**[Agent2Agent (A2A)](https://a2a-protocol.org/latest/)** is an open protocol that standardizes agent communication, i.e. sending and receiving messages in any format (text, audio, images, files, etc.), discovery, collaboration, authentication, etc.
Essentially, if MCP provides a standard interface for agents to use tools, A2A provides a standard interface for users and agents to use agents.
StackOne provides **production-ready A2A agents** for each linked account, giving you and your AI agents direct access to agents built for StackOne platform actions. See the complete list at [stackone.com/integrations](https://www.stackone.com/integrations).
**Not sure if A2A is right for you?** Check out our [Agent Protocols Guide](/guides/calling-stackone-actions) to understand when to use A2A vs MCP vs AI Toolset (SDK).
**What is A2A?** The Agent2Agent (A2A) Protocol is an open standard originally developed by Google and now maintained by the Linux Foundation. It defines how AI agents discover each other, authenticate, and exchange messages - regardless of what framework they were built with or who built them. Think of it as a common language that lets any agent talk to any other agent.
**Why does A2A exist?** Without a standard protocol, connecting agents requires custom integrations for every pair of agents. A2A solves this by providing a single, universal interface. Your agent built with LangGraph can collaborate with an agent built with CrewAI, ADK, or any other framework - all using the same protocol.
**How does it work?** A2A uses familiar web standards: HTTP for transport, JSON-RPC 2.0 for message format, and standard authentication methods. Agents publish an **Agent Card** (a JSON document describing their capabilities and skills) at a well-known URL. Clients fetch this card to discover what an agent can do, then send **Messages** to request work. The agent processes the request and returns either a direct response or a **Task** for longer-running operations.
**A2A vs MCP**: These protocols are complementary, not competing. MCP (Model Context Protocol) standardizes how agents connect to **tools** - stateless functions like calculators or database queries. A2A standardizes how agents communicate with **other agents** - autonomous systems that can reason, plan, and have multi-turn conversations. Use MCP when you need tools; use A2A when you need to collaborate with other agents.
**Simplified Authentication**: Authentication to third-party providers is completely abstracted - you only need your StackOne API key and account ID to access all integrated systems. Accounts must be linked beforehand through the [StackOne Integration Hub](/guides/accounts-section) or via [auth links](/guides/auth-link).
## A2A or MCP?
You can use StackOne platform actions not only with A2A agents, but also with [MCP Servers](/mcp/quickstart) and the [Actions endpoint](/platform/api-reference/actions/make-an-rpc-call-to-an-action).
Ultimately, experimentation is the best way to decide for your use case. However, here are some reasons you might try A2A vs. MCP:
A2A agents are pre-built agents that are ready to go. No need to set up agent deployment, memory, etc. Just send text directly to the relevant agent with your StackOne API key and account ID.
Create a multi-agent system with a single agent in your preferred framework. Just set up your custom orchestrator agent with the A2A MCP.
Context bloat reduces the reliability of complex projects. Replacing tools with agents keeps tool calls out of the context, and improves accuracy and maintainability as your system grows.
StackOne lets your agents discover and execute business actions with minimal setup, secured by unified enterprise authentication.
## How StackOne A2A Works
```mermaid theme={null}
flowchart LR
Client[A2A Client/Agent] <-->|JSON-RPC 2.0| StackOneA2A[StackOne A2A Agent]
StackOneA2A <-->|MCP Streamable HTTP| StackOneMCP[StackOne MCP Server]
StackOneMCP <-->|tools/list| Toolset[StackOne Tool Catalog]
StackOneMCP <-->|tools/call| Providers[(Connected SaaS APIs)]
IntegrationConfig[Integration & Account Settings] -->|Defines available tools| Toolset
style StackOneA2A fill:#10b981,stroke:#059669,color:#fff
style StackOneMCP fill:#10b981,stroke:#059669,color:#fff
style Toolset fill:#10b981,stroke:#059669,color:#fff
style IntegrationConfig fill:#10b981,stroke:#059669,color:#fff
```
When you send your StackOne API key and account ID to `https://a2a.stackone.com` to use the agent, its system message and [MCP server](/mcp/quickstart) are dynamically generated based on your account's configured integrations and enabled actions in the StackOne dashboard.
**Agent Card Routes:**
* **For connecting to agents:** Always use `https://a2a.stackone.com/.well-known/agent-card.json`. This route dynamically loads the agent card based on your account's configured integrations and enabled actions.
* **For viewing available skills:** Connector-specific routes like `https://a2a.stackone.com/hibob/agent-card.json` are available for inspecting all available skills for a specific connector. These are for reference only and should not be used for agent connections.
## Key Features
* **Ready to Use**: Pre-built agents with memory, etc.
* **Agent per Integration**: Each StackOne Integration (aka Provider or Connector) has its own A2A agent
* **Automatically Customised**: The A2A agent is dynamically generated based on your account's configured integrations and enabled actions
* **Production Ready**: Authentication, rate limiting, and security built-in
## Getting Started
Get started with the A2A UI and cURL
Learn about headers, authentication, and security
Use the official A2A SDKs to build your own tools
Build agents in frameworks with A2A integrations
## Integration Options
StackOne A2A agents can be used in two ways, depending on your use case:
### A2A SDK
There are official A2A SDKs for [Python](https://github.com/a2aproject/a2a-python), [JavaScript](https://github.com/a2aproject/a2a-js), [Go](https://github.com/a2aproject/a2a-go), and [more](https://github.com/orgs/a2aproject/repositories). Use these to **build your own tools** in your preferred framework to send messages to StackOne's A2A agents.
See a complete working example in the [StackOne A2A Agents Orchestrator Demo](https://github.com/StackOneHQ/a2a-demo), which shows how to build an orchestrator agent that routes requests to multiple StackOne A2A agents using the JavaScript SDK.
### Agent Frameworks
There are official A2A integrations for [Agent Development Kit (ADK)](https://google.github.io/adk-docs/a2a/), [AG2](https://docs.ag2.ai/latest/docs/user-guide/a2a/), [BeeAI Framework](https://framework.beeai.dev/integrations/a2a), and [more](https://framework.beeai.dev/integrations/a2a). Build agents in these frameworks to easily send messages to StackOne's A2A agents.
## Next Steps
Ready to connect your AI agents to StackOne? Start with our [Quickstart Guide](/a2a/quickstart) or jump directly to the [A2A Python SDK](https://github.com/a2aproject/a2a-python), [A2A JavaScript SDK](https://github.com/a2aproject/a2a-js), or your preferred framework.
For more information about StackOne's platform capabilities, see our [AI Tools documentation](/agents/typescript/introduction).