Skip to main content
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) 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. Use these agents from your own code, from multi-agent frameworks, or from agent platforms like Gemini Enterprise and Microsoft Foundry.
Not sure if A2A is right for you? Check out our Agent Protocols Guide to understand when to use A2A vs MCP vs AI Toolset (SDK).

​
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 for details.
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 or via auth links.

​
A2A or MCP?

You can use StackOne platform actions not only with A2A agents, but also with MCP Servers and the Actions endpoint. 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 in your preferred framework. Set up your orchestrator agent to delegate tasks to StackOne’s A2A agents.
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

StackOne A2A agents are ready-to-use agents that speak the Agent2Agent (A2A) protocol 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.
The server is built on Google’s Agent Development Kit (ADK): each request runs an agent on a Gemini model through an ADK Runner. The StackOne ADK plugin 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 executes it against the StackOne Actions API.The protocol itself is implemented with Google’s A2A Python SDK, 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 guide.
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.

​
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

Quickstart

Get started with the A2A UI and cURL

Authentication

Learn about headers, authentication, and security

A2A SDK

Use the official A2A SDKs to build your own tools

Agent Guides

Build agents in frameworks with A2A integrations

​
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, JavaScript, Go, and more. 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.

Google ADK

Call StackOne from a Google ADK agent

AG2

Delegate to StackOne from an AG2 agent

BeeAI Framework

Consume StackOne as a remote A2A agent

Strands Agents

Add StackOne A2A tools to a Strands agent

​
Agent Platforms

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

Gemini Enterprise

Use StackOne agents from Google’s platforms

Microsoft Foundry

Connect a Foundry agent to StackOne

​
Next Steps

Ready to connect your AI agents to StackOne? Start with our Quickstart Guide or jump directly to the A2A Python SDK, A2A JavaScript SDK, or your preferred framework.