> ## 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.

<Warning>
  **Open Beta Feature**: StackOne A2A agents are currently in open beta. While fully functional, the API and features may evolve based on user feedback.
</Warning>

**[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).

Use these agents from your own code, from multi-agent frameworks, or from agent platforms like [Gemini Enterprise](/a2a/platform-guides/gemini-enterprise) and [Microsoft Foundry](/a2a/platform-guides/microsoft-foundry).

<Tip>
  **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).
</Tip>

***

## A2A Server Endpoint

```
https://a2a.stackone.com
```

A2A clients discover the agent from the public card at `https://a2a.stackone.com/.well-known/agent-card.json`, which needs no authentication.

**Headers for authenticated requests** (`agent/authenticatedExtendedCard`, `message/send`, `message/stream`):

* `Authorization: Basic <base64 of "<api_key>:">` (note the trailing colon)
* `x-account-id: <account_id>`

Authentication to third-party providers is completely abstracted, you only need your StackOne API key and account ID. See [Authentication](/a2a/auth-security) for details.

***

<Accordion title="A2A 101: Understanding the Protocol" icon="graduation-cap">
  **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.
</Accordion>

**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:

<AccordionGroup>
  <Accordion title="Quick Setup" icon="bolt-lightning">
    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.
  </Accordion>

  <Accordion title="Multi-agent Systems" icon="network-wired">
    Create a multi-agent system in your preferred framework. Set up your orchestrator agent to delegate tasks to StackOne's A2A agents.
  </Accordion>

  <Accordion title="Complex Projects" icon="diagram-project">
    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.
  </Accordion>
</AccordionGroup>

<Note>
  StackOne lets your agents discover and execute business actions with minimal setup, secured by unified enterprise authentication.
</Note>

## How StackOne A2A Works

StackOne A2A agents are ready-to-use agents that speak the [Agent2Agent (A2A) protocol](https://a2a-protocol.org/latest/) at `https://a2a.stackone.com`. Each agent is scoped to your linked account, and the tools it offers reflect that account's configured integrations and enabled actions.

```mermaid theme={null}
%%{init: {'theme':'base','themeVariables':{'actorBkg':'#10b981','actorBorder':'#047857','actorTextColor':'#ffffff','signalColor':'#334155','signalTextColor':'#334155','noteBkgColor':'#ecfdf5','noteBorderColor':'#10b981','noteTextColor':'#065f46'}}}%%
sequenceDiagram
    autonumber
    participant C as Your client or agent
    participant S as StackOne A2A server
    participant A as StackOne actions
    C->>S: A2A request
    S->>A: run actions
    A-->>S: result
    S-->>C: response (SSE)
    Note over S: continually improving
```

<Accordion title="Under the hood" icon="layer-group">
  The server is built on Google's [Agent Development Kit (ADK)](https://google.github.io/adk-docs/): each request runs an agent on a Gemini model through an ADK Runner. The [StackOne ADK plugin](https://adk.dev/integrations/stackone/) exposes your account's actions, across StackOne's 200+ providers, through a search-and-execute tool model, the model gets one tool to search the action catalog and one to execute a chosen action, so the prompt stays a constant size as you link more connectors. When the model runs a tool, the [StackOne SDK](https://github.com/StackOneHQ/stackone-ai-python) executes it against the StackOne Actions API.

  The protocol itself is implemented with Google's [A2A Python SDK](https://github.com/a2aproject/a2a-python), which handles `message/send`, `message/stream`, and tasks. Conversation and task state is persisted, so multi-turn conversations and long-running tasks survive across requests.

  Building on ADK keeps StackOne agents interoperable with the wider Google agent ecosystem. It is the same plugin and SDK StackOne ships to customers, so you can use them to build your own A2A agent, see the [Python Toolset](/agents/python/introduction) guide.
</Accordion>

<Note>
  **Agent Card Routes:**

  * **For connecting to agents:** point your client at `https://a2a.stackone.com/.well-known/agent-card.json`. A2A clients read this public card and then fetch your account-specific skills from the authenticated extended card at `https://a2a.stackone.com/agent/authenticatedExtendedCard`.
  * **For viewing a connector's skills:** connector-specific routes like `https://a2a.stackone.com/hibob/agent-card.json` are public reference cards for inspecting one connector's skills. They are for reference only and should not be used for agent connections.
</Note>

## Key Features

* **Ready to Use**: Pre-built agents with conversation memory built in
* **Scoped to your account**: The agent is scoped to your linked account, and its skills come from that account's connected integration (also called a provider or connector)
* **Automatically Customised**: The A2A agent is tailored to your account's configured integrations and enabled actions
* **Multiple accounts in one request**: Pass several account IDs to span connectors in a single call
* **Constant context**: A search-and-execute tool model keeps prompt size steady as you link more connectors
* **Production Ready**: Authentication and security built-in

## Getting Started

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/a2a/quickstart">
    Get started with the A2A UI and cURL
  </Card>

  <Card title="Authentication" icon="shield" href="/a2a/auth-security">
    Learn about headers, authentication, and security
  </Card>

  <Card title="A2A SDK" icon="code" href="/a2a/a2a-sdk">
    Use the official A2A SDKs to build your own tools
  </Card>

  <Card title="Agent Guides" icon="robot" href="/a2a/framework-guides/adk">
    Build agents in frameworks with A2A integrations
  </Card>
</CardGroup>

## Integration Options

StackOne A2A agents can be used in a few 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.

### Agent Frameworks

StackOne speaks the open A2A protocol, so any framework that can act as an A2A client can talk to the StackOne agent. These guides are examples, not an exhaustive list.

<CardGroup cols={2}>
  <Card title="Google ADK" icon="google" href="/a2a/framework-guides/adk">
    Call StackOne from a Google ADK agent
  </Card>

  <Card title="AG2" icon="users" href="/a2a/framework-guides/ag2">
    Delegate to StackOne from an AG2 agent
  </Card>

  <Card title="BeeAI Framework" icon="bee" href="/a2a/framework-guides/beeai">
    Consume StackOne as a remote A2A agent
  </Card>

  <Card title="Strands Agents" icon="robot" href="/a2a/framework-guides/strands">
    Add StackOne A2A tools to a Strands agent
  </Card>
</CardGroup>

### Agent Platforms

Register StackOne A2A agents in platforms that call an agent by its URL.

<CardGroup cols={2}>
  <Card title="Gemini Enterprise" icon="google" href="/a2a/platform-guides/gemini-enterprise">
    Use StackOne agents from Google's platforms
  </Card>

  <Card title="Microsoft Foundry" icon="microsoft" href="/a2a/platform-guides/microsoft-foundry">
    Connect a Foundry agent to StackOne
  </Card>
</CardGroup>

## 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.