Agent Engine and A2A: Google makes cross vendor agents real

The week multi-agent systems grew up

On September 18, 2025, Google Cloud put a flag in the ground with a platform refresh that makes multi-agent systems feel practical for real production work. Vertex AI Agent Builder now unifies design, deployment, and governance, while Agent Engine gives those agents a managed home, and the Agent-to-Agent protocol unblocks cross-vendor teamwork. If you only read one thing, read Google’s own overview in the Vertex AI Agent Builder announcement.

The headline is not that you can build agents. You already could. The shift is that enterprises can now standardize how agents talk to each other, ship them behind proven controls, and watch what they do with production-grade tracing. Imagine last year’s agent prototypes as hobby drones and this release as the air traffic system, airports, and safety rules that let fleets deliver packages across a city.

What actually shipped, in plain English

Agent Engine: a fully managed runtime where you deploy agents without standing up your own scaffolding. It takes care of scale, reliability, and security. It adds practical niceties like sessions with memory, code execution in a sandbox, and bidirectional streaming so agents can hold real-time conversations with users.
Agent Builder suite: an opinionated, end-to-end workflow that includes the Agent Development Kit for building, Agent Garden for examples, and managed evaluation. It supports popular frameworks, so you do not have to rewrite teams’ work to run in production.
A2A protocol: a common language so agents built on different stacks can collaborate. Think of it like USB for agents. Publish what an agent can do, negotiate how to talk, then hand tasks off securely and traceably.
Connectors and guardrails: more than 100 pre-built connectors to systems such as CRMs, IT workflows, and files; Model Context Protocol support for tool ecosystems; Apigee for governed APIs; plus identity, customer-managed encryption keys, private networking, and compliance.
Tracing and observability: first-class traces of agent steps, tool calls, and outcomes so you can debug, evaluate, and show auditors the exact path an agent took to act.

The point is not a single feature. It is the composition. You can wire agents together across stacks, ground them in trusted data, watch everything they do, and roll them out to actual users without a months-long platform build.

Why this is a strategic shift

For the past 18 months, most organizations learned the same lesson: one clever agent is helpful, but systems of cooperating agents are where durable productivity shows up. Those systems cross vendor lines by nature. A sales agent might live near Salesforce automation. A finance agent might sit next to your ERP. A product agent might run inside engineering tools. Without a standard and a managed home, every handoff becomes a brittle integration.

A2A and Agent Engine change the slope of that curve. You get both the open handshake for collaboration and the paved road to production. That combination is the new battleground. The winners will be the teams that ship useful multi-agent workflows quickly and safely, not the ones that argue over the one true framework.

A2A got real in July, and it matters

On July 31, 2025, Google announced version 0.3 of the A2A protocol, adding gRPC support, signed security cards, and stronger client tooling. See the details in the A2A protocol version 0.3 update. In practice, those changes matter because:

gRPC gives you efficient, type-safe calls between agents across networks without inventing your own transport.
Signed security cards help enforce who is allowed to do what, which is essential once agents span organizations.
Better client libraries reduce the glue code teams write just to get a prototype off the ground.

That is why you now see partners lining up behind the protocol. When big vendors agree on how agents describe capabilities and call each other, a marketplace becomes possible. You can imagine buying an invoicing agent from one vendor, a knowledge routing agent from another, and a domain policy agent from your security team, then snapping them together under your controls.

What this unlocks for teams today

Here are four paths you can move on immediately.

Real-time assistants that actually integrate with your systems

Bidirectional streaming plus 100+ enterprise connectors means you can build assistants that listen, talk, and act in one flow. A claims agent can take voice input, pull policy documents, fill a form in your case system, and schedule follow-ups on the call. No intermediate batch jobs. No swivel-chair workflows.

Multi-agent workflows that cross stacks without custom contracts

With A2A, agents can advertise a capability, agree on input and output, and swap tasks. A store operations agent can ask a finance agent to validate a promotion budget, then delegate to a logistics agent to verify stock coverage, even if those agents come from different vendors.

Safer deployments in regulated environments

Agent Engine supports enterprise controls like private networking and customer-managed keys, and you can run behind organization policies. That reduces the time your platform and security teams spend inventing basic guardrails. Tracing gives you a single place to prove what happened, which shortens audit cycles.

Faster iteration loops

Because the runtime is managed, you can ship a thin pilot, capture traces, and fix failure modes in hours instead of weeks. Example Store and evaluation tools help you measure progress with real data rather than anecdotes.

A simple architecture pattern you can reuse

If you are starting from a greenfield workflow, this reference works well on day one and continues to work as you scale.

Interaction agent: handles the conversation, speech, or UI. It streams inputs and outputs, keeps session memory, and enforces top-level safety instructions.
Orchestrator agent: receives intents and decides which sub-agents to involve. It speaks A2A and tracks stepwise progress.
Specialist agents: narrow responsibilities such as pricing, policy checks, data extraction, or approvals. These can be built in different frameworks and even hosted by partners, as long as they speak A2A.
Tooling layer: connectors, MCP tools, and house APIs behind Apigee to give agents governed actions and up-to-date context.
Observability and controls: tracing, metrics, and audit logging across the full path, not just model calls.

This pattern maps cleanly to the current product set. The interaction and orchestrator agents run on Agent Engine. Specialist agents can live on or off the platform as long as they implement the protocol. The tooling layer plugs into Integration Connectors, MCP, and your APIs. Traces unify it.

For a deeper dive on identity and perimeter controls, compare this pattern with how identity becomes a lever in agent design in our piece on identity as the control plane. For edge execution and tool remoting, see how edge-native patterns emerge in edge native agents and MCP. If you are standardizing experiment tracking and evaluation, our write up on MLflow and agent bricks pairs well with the tracing model described here.

Interop is not a nice to have, it is a risk reducer

Cross-vendor standards reduce two real risks: lock-in and shadow stacks. When teams cannot connect agents, they fork frameworks and set up one-off services. Six months later you are paying for three runtimes, duplicating safety logic, and troubleshooting four kinds of streaming. A2A does not eliminate architectural drift, but it channels it into a pattern the platform can observe and secure.

The lift for platform and security teams changes shape. Instead of writing glue code and custom transports, they define contracts, approve connectors, and monitor traces. That is a better use of scarce talent.

How a marketplace could actually work

A marketplace is not just a catalog. It is procurement, billing, and governance wrapped around capabilities that plug into your environment. A2A gives the plug shape. Agent Engine and your identity controls define the outlet.

Vendors can publish agents that meet documented interaction contracts and safety expectations, and customers can test them in sandboxes with trace visibility. Over time, you will see vertical agents that encode domain know-how, horizontal agents for common tasks like document triage, and oversight agents that enforce policies across the others.

The important implication: your buy versus build decisions get faster. If a partner agent meets the A2A contract and passes your controls, you can slot it into the orchestrator today, then replace it later without tearing up the floor.

What might block you, and how to avoid it

Fragmented identity: If some agents act on behalf of users and others act as service accounts, access checks can diverge. Standardize a pattern per workflow and log the principal on every tool call.
Silent failure in tools: Agents often fail at the tool edge, not the model. Wrap connectors with retries and structured errors that bubble back to the orchestrator. Create canary flows.
Prompt drift: When three agents rewrite each other’s context, instructions blur. Treat system messages like code. Version them, diff them, and pin them per release.
Overspending on real-time: Streaming is powerful and expensive. Only keep the channel open when the user is present or you are collecting signals that improve the experience.

A practical checklist to ship cross-vendor agents fast and safely

Use this to move from prototype to production in 30 to 60 days.

Frame the job to be done

Write a one-page user story for the end-to-end task: entry, handoffs, success criteria, and failure modes. Define the single measure of success you will move in the first release.

Pick an orchestration home

Choose Agent Engine for managed scale and tracing. Document the fallback if you must deploy a specialist agent to another runtime.

Define the A2A contracts first

For each agent, write a short capability card: inputs, outputs, side effects, and trust model. Decide which agent can call which others and under what identity.

Ground agents in facts

Map the minimum truth sources and actions. Prefer existing APIs behind Apigee and one of the 100+ connectors. Add Model Context Protocol tools only where they reduce custom glue.

Secure by default

Enforce organization policies, customer-managed keys, and network perimeters at the environment level. Decide whether agents act as the user or as a service account in each step.

Make traces your contract tests

For every path in your user story, capture the expected trace shape. Fail builds if step names or tool contracts change without review.

Start with a thin slice

Ship the shortest path that produces value. For everything else, stub a specialist agent that returns a canned response. Replace stubs one by one with real agents.

Prove the economics

Track latency, cost per successful task, and human time saved. Tie at least one of those to a business metric your sponsor cares about.

Plan for rollback

Use blue-green releases and a feature flag to disable individual agents. Put a human in the loop on high-risk steps and require dual confirmation for irreversible actions.

Prepare procurement for the marketplace era

Write a one-page vendor checklist with A2A compliance, trace export, data residency, and support commitments. If a partner agent clears those, you can trial it in days, not quarters.

Concrete examples to copy

Customer support triage: An interaction agent on streaming audio routes calls by intent, asks a billing specialist agent to check entitlement, and delegates to a knowledge agent to synthesize a step-by-step answer grounded in case history. Traces show the full path for every resolution.
Sales to fulfillment: A pricing agent quotes using approved rules, an order agent posts to your ERP through a connector, and a logistics agent checks stock at a warehouse partner over A2A. Exceptions escalate to a human with the trace attached.
Compliance attestation: A policy agent evaluates every tool call against a ruleset. If an agent requests a sensitive action without the right principal, it is blocked with a reason and the orchestrator gets a structured error to inform the user.

How to explain this to your CFO and CISO

CFO: The managed runtime cuts platform work and speeds time to value. A2A reduces vendor risk because you can slot in partner agents without rewriting the system. Traces let you prove productivity and tune cost per task.
CISO: Agent Engine is deployable behind your network and keys. A2A signed cards and controlled handoffs reduce lateral movement risk. Tracing gives you deterministic visibility when something goes wrong.

What to watch in the next quarter

Partner agents that speak A2A out of the box. As more vendors publish capability cards, expect usable multi-agent workflows without custom adapters.
Real-time experiences beyond chat. Audio and video streams enable agents that co-pilot complex tasks, like filling procedures while a clinician examines a patient or walking a field technician through a repair.
Procurement patterns that treat agents like reusable components rather than bespoke projects. That will compress deployment cycles from quarters to weeks.

The bottom line

Interoperability and enterprise-grade deployment are now the arena where agent platforms will win or lose. With Agent Engine as a production-ready runtime and A2A as a workable open handshake across stacks, Google’s September release takes multi-agent systems from plausible to practical. If you have a workflow with clear value, you can ship it this quarter. Pick one job. Define the A2A contracts. Ground the agents in the right data. Make tracing your truth. That is how you turn a promising demo into durable impact.