Inside StackOne's Agent: Built on A2A, ADK, and Gemini

Recent advancements in Agentic AI have not only made agents better but enabled agents to work alongside one another, not just with tools. Google has built much of the open foundation for that world: the Agent2Agent protocol (A2A) for how agents talk to one another, the Agent Development Kit (ADK) for building them, the Gemini models to power them, and Gemini Enterprise to put them in front of every employee.

StackOne’s agent is built on all four. It exposes StackOne’s entire integration catalog, across more than 300 connectors, to any agent that speaks A2A. The result is, instead of wiring your agent to every business system individually, you connect StackOne once, and hundreds of integrations come with it.

A2A: An Open Standard for Agent Interoperability

Google introduced the Agent2Agent protocol in 2025 and donated it to the Linux Foundation, where it is now developed under vendor-neutral governance alongside MCP (Model Context Protocol). In the project’s own words, A2A is “an open standard for seamless communication and collaboration between AI agents,” the common language that lets agents from different vendors and frameworks work together instead of through brittle, point-to-point integrations. In its first year the protocol passed 150 supporting organizations, including Google, Microsoft, Salesforce, ServiceNow, and SAP.

The mechanics are deliberately simple. An agent publishes an agent card, a small document that advertises its identity, its skills, and how to authenticate. Clients discover that card, send messages, and track longer-running work as tasks, with streaming updates over a standard connection. The design principles are the ones an enterprise cares about: simplicity, enterprise readiness, asynchronous long-running work, and opaque execution, so agents can collaborate without exposing their internal logic.

Because StackOne’s agent speaks A2A, any A2A client can use it, and that includes Google’s own platforms. StackOne does not build a separate integration for each agent framework. It implements the standard once and interoperates with the whole ecosystem.

Google’s Agent Development Kit: The Runtime

If A2A is the protocol, the Agent Development Kit is the runtime. It is an open-source, code-first toolkit for building, evaluating, and deploying sophisticated AI agents with flexibility and control. It is optimized for Gemini yet model-flexible, supports multi-agent systems and a rich tool ecosystem, and deploys onto Google Cloud, from Agent Engine to Cloud Run, with managed infrastructure, authentication, and tracing built in. StackOne’s agent uses ADK as its engine room: the agent loop, the conversation sessions that persist across turns, and the lifecycle hooks all come from ADK, maintained and advanced by Google rather than by us.

What links ADK to StackOne’s catalog is the StackOne ADK plugin, and it is officially published in Google’s ADK integrations directory under Connectors, at adk.dev/integrations/stackone. Instead of hand-coding a tool function for each API, it dynamically discovers available tools from your connectors and exposes them as native tools in ADK, across more than 300 providers spanning human resources, applicant tracking, customer relationship management, ticketing, productivity, and scheduling. A developer adds it to an ADK agent with a single dependency and chooses between a standard mode that registers every discovered tool and a search-and-execute mode that registers only two.

That published plugin is the same component running inside StackOne’s A2A server. Under the hood, every request builds an ADK Runner around a Gemini agent and attaches the StackOne plugin as its toolset, the same shape as Google’s own quickstart on that listing, with search-and-execute mode switched on. The integration Google lists for every ADK developer is the production engine of StackOne’s agent, so any improvement to the plugin reaches both at the same time.

Gemini: The Engine, at Constant Context

Every turn of StackOne’s agent runs on Gemini. The default is the latest Gemini Flash model, part of Google’s newest Gemini generation, which Google has tuned for exactly this kind of agentic and tool-calling work. Configuration is a single model name in ADK, and an organization can point it at a different model when it needs to, but Gemini is the native default.

The interesting problem is scale. A normal agent exposes every action of every connected system to the model as a separate tool, so an account with a few large connectors can place hundreds of tool definitions into the prompt on every turn. Cost and latency then climb with each system a customer connects, and accuracy falls as the list grows. StackOne’s plugin has a search-and-execute mode that uses Google’s ADK and Gemini model, which sees only two tools, one to search the catalog and one to execute a chosen action. The model discovers what it needs on demand, so the prompt stays a constant size whether an account has connected three systems or thirty.

The whole path is short:

                a2a.stackone.com
                        |
                 [CDN + load balancer]
                        |
        +---------------+---------------+
        |    StackOne agent (Python)    |
        |    a2a-sdk   (A2A protocol)   |
        |    google-adk Runner          |
        |    StackOne ADK plugin        |
        +---------------+---------------+
                        | direct REST
                        v
               api.stackone.com  /actions
                        |
                        v
              the connected business system

In code, putting hundreds of systems behind a Gemini agent takes only a few lines:

plugin = StackOnePlugin(
    api_key=api_key,
    account_ids=account_ids,
    mode="search_and_execute",
)

agent = LlmAgent(
    model="gemini-flash-latest",
    name="stackone_agent",
    instruction=SYSTEM_PROMPT,
    tools=plugin.get_tools(),
)

runner = Runner(app_name="stackone_a2a", agent=agent, ...)

Gemini Enterprise: StackOne Agents

Google’s agent stack does not stop at the developer. Gemini Enterprise, Google’s agentic platform for business, brings agents to knowledge workers as an assistant grounded in their company’s data. Google frames it as an end-to-end system for the agentic era, and its Agent Gallery lets employees discover and use agents made by Google, built by their own organization, or supplied by partners, each invoked in chat with a simple mention.

This is where building on the standard pays off most directly. Gemini Enterprise accepts partner agents that are, in Google’s words, built on Google ADK and the A2A protocol. An external agent is registered with its agent card and a public endpoint, and StackOne’s agent fits that shape exactly. Its card declares A2A 0.3, which is the protocol version Gemini Enterprise registers today, and for host surfaces that cannot attach authentication headers, StackOne offers a credential-in-URL card so the agent can be registered with a single static link and still authenticate to the right account. Partner agents reach the marketplace alongside names like Workday, Salesforce, and ServiceNow after Google’s own validation pathway.

An employee in Gemini Enterprise can ask StackOne’s agent to act across their connected systems, and a single request can even span several connected accounts at once, without the organization standing up any agent infrastructure of its own.

Moving Forward with Google

The A2A protocol reached its 1.0 milestone in 2026. Google’s ADK and Gemini Enterprise currently operate on A2A 0.3, and StackOne’s agent speaks 0.3 to match, which is exactly what those platforms register and consume today. There is no gap to manage. As Google’s runtime adopts 1.0, StackOne adopts it in step.

That is the advantage of building on the standard pieces rather than around them. As ADK gains capabilities, as the Gemini models improve, and as Gemini Enterprise extends what agents can do, StackOne’s agent inherits those gains through an upgrade rather than a rewrite. And as StackOne’s own platform grows, with every new connector and every improvement to the plugin, that value flows into the same agent. The Google ecosystem and the StackOne catalog advance on their own schedules, and the agent rides both.

One AI Agent Integration Gateway, Inside Google’s Ecosystem

StackOne is the AI Agent Integration Gateway: one gateway, hundreds of systems, thousands of actions. Built on Google’s open agent stack, that gateway is now reachable by any agent that speaks A2A, drivable by any Gemini or ADK agent a team builds, and available directly inside Gemini Enterprise. The integration work that every agent project used to repeat is solved once, on the protocol and the runtime that Google is standardizing the industry around, so a customer’s agents can act across their business systems wherever those agents run.