Google ADK 1.0 + A2A Protocol — Python/Go/Java/TypeScript GA, AgentCard, Task, and SSE Redefining the 2026 Multi-Agent Standard

At Google Cloud Next 2026 in April, the Agent Development Kit (ADK) graduated to 1.0 GA across four languages — Python, Go, Java, and TypeScript — simultaneously. In the same window, the Agent2Agent (A2A) protocol crossed 150+ organizations in production under the Linux Foundation, and Anthropic's MCP (donated to the Linux Foundation in December 2025) settled in as the de-facto standard for tool calls. The 2026 multi-agent stack now sits on a clean separation: MCP for tools, A2A for agents, ADK (or equivalent) for orchestration. This post documents the architectural decisions, code patterns, and operational checklist that the ManoIT AI platform team produced while integrating ADK 1.0 + A2A into our internal RAG and orchestration backend.

1. Why May 2026 Is the Inflection Point

The agent landscape in 2025 was a framework war — LangGraph for graph control, CrewAI for ergonomic multi-agent, AutoGen for research, and vendor-specific SDKs from OpenAI and Anthropic. By April–May 2026 that fragmentation collapsed onto two protocols and one cross-language SDK.

Axis	H1 2025	May 2026	Practical impact
Tool calls	Per-framework SDKs	MCP (Linux Foundation)	A tool built once works across Claude, Gemini, GPT, and self-hosted LLMs
Agent-to-agent	Vendor silos	A2A v1.0, 150+ orgs in prod	Salesforce ↔ Vertex ↔ ServiceNow speak one wire format
Code-first SDK	Fragmented	ADK 1.0 GA in Py/Go/Java/TS	One semantic, four languages, model-agnostic
Managed runtime	DIY	Vertex AI Agent Engine + Bedrock AgentCore + Azure AI Foundry	Sessions, memory, observability as a service
Vertex AI brand	Vertex AI Agent Builder	Gemini Enterprise Agent Platform	Catalog of 200+ models including Claude

The bottom line: picking a multi-agent system is no longer a framework decision but a protocol-fit decision. Whichever framework you choose has to consume MCP tools and accept A2A delegations. ADK 1.0 is the first cross-language SDK that treats both as first-class citizens.

2. ADK 1.0 GA — Feature Parity Across Four Languages

The headline of ADK 1.0 is feature parity. Where the LangChain ecosystem in 2025 was Python-first, JS-second, and other languages a distant third, ADK 1.0 explicitly aligned all four runtimes so that an agent prototyped in Python can be re-implemented in Java for production without semantic drift.

Language	Release	Signature 1.0 features	Typical adoption
Python	Continuous (bi-weekly)	Plugin system, Event Compaction, FileArtifactService, Service Registry (services.yaml), Vertex AI Agent Engine Sandbox code execution, Anthropic thinking blocks, OTel agentic metrics	RAG, LangGraph replacement, research
Java	1.0.0 (Apr 2026)	GoogleMapsTool, UrlContextTool, ContainerCodeExecutor, VertexAICodeExecutor, ComputerUseTool, HITL ToolConfirmation, Event Compaction, native A2A	Finance, SI, enterprise backends
Go	1.0 (Apr 2026)	YAML agent config, native OpenTelemetry, cross-language parity	High-concurrency microservices, edge
TypeScript	Aligned to 1.0	Same patterns from front-end to BFF	Web chat, BFF, Slack/Teams bots

2.1 ADK Python — Plugins and the Service Registry

The Python 1.0 line collapses into two abstractions worth understanding. First, Plugin is a cross-cutting hook registered once on the Runner and invoked globally before/after every Agent, Model, and Tool call. Second, the Service Registry lets you swap session/artifact/memory backings declaratively in services.py or services.yaml so the same agent can run on in-memory backends locally and on Vertex AI Memory Bank, Firestore sessions, and GCS artifacts in production without code changes.

# agents/customer_support/agent.py
# Note: ADK 1.0 requires Python 3.10+
from google.adk.agents import LlmAgent
from google.adk.tools import google_search
from google.adk.tools.openapi_tool import OpenAPIToolset
from google.adk.plugins import Plugin

# 1) Cross-cutting concerns — PII masking and prompt injection defense as a Plugin
class GuardrailPlugin(Plugin):
    async def before_model_callback(self, ctx, request):
        request.contents = self._mask_pii(request.contents)
        return request

    async def after_tool_callback(self, ctx, tool, result):
        ctx.logger.info(f"tool={tool.name} status={result.status}")
        return result

# 2) Agent — model-agnostic (Gemini, Claude, GPT, Llama all swap freely)
support_agent = LlmAgent(
    name="customer_support",
    model="gemini-2.5-pro",          # or "claude-opus-4-6", "gpt-5", "vllm://..."
    description="ManoIT first-line support agent",
    instruction=(
        "Reply in the user's language. "
        "Delegate billing/refund/account issues to 'billing_agent'."
    ),
    tools=[
        google_search,
        OpenAPIToolset(spec_url="https://api.manoit.co.kr/openapi.json"),
    ],
    sub_agents=["billing_agent"],     # delegated via A2A or in-process
)

# services.yaml — swap backings per environment
sessions:
  type: vertex_ai
  config:
    project: manoit-prod
    location: asia-northeast3

memory:
  type: vertex_ai_memory_bank
  config:
    corpus: projects/manoit-prod/locations/asia-northeast3/ragCorpora/12345

artifacts:
  type: gcs
  config:
    bucket: manoit-agent-artifacts

2.2 ADK Java — Human-in-the-Loop and Computer Use

ADK Java 1.0's signature feature is HITL ToolConfirmation. Risky tools (refunds, permission grants, expensive operations) pause execution before the call, wait for human approval, and resume cleanly. Add ComputerUseTool, ContainerCodeExecutor, and VertexAICodeExecutor and the agent can drive a real browser or run generated code in a sandbox. Together they make "cautious automation" — the most common enterprise requirement — a standard pattern rather than a custom build.

2.3 Event Compaction — Beating the Context Window Honestly

Every long-running LLM agent eventually hits the same wall: context explosion. ADK 1.0's Event Compaction keeps a sliding window of recent events and summarizes the rest, capping the token budget. In ManoIT's internal tests on 12-turn dialogues, compaction cut average token usage by 38% and latency by 18%. The catch: compaction can also drop "decisions you must remember." Use memory_keys to pin user IDs, contract terms, and in-flight payments outside the compactor.

3. A2A Protocol — AgentCard, SkillCard, and the Task Lifecycle

A2A is a wire format for delegating work between opaque agents. You don't need to know the other agent's model, prompt, or memory layout — only that it exposes an AgentCard, that the AgentCard advertises SkillCards, and that calls flow as JSON-RPC 2.0 over HTTP(S).

3.1 AgentCard — The Digital Business Card

{
  "name": "manoit-billing-agent",
  "description": "ManoIT billing, refund, and subscription agent",
  "version": "1.0.0",
  "url": "https://agents.manoit.co.kr/billing/a2a",
  "supported_interfaces": [
    {"protocol": "a2a/1.0", "transport": "https+jsonrpc"}
  ],
  "capabilities": {
    "streaming": true,
    "push_notifications": true,
    "long_running_tasks": true
  },
  "default_input_modes":  ["text/plain", "application/json"],
  "default_output_modes": ["text/plain", "application/json"],
  "skills": [
    {
      "id": "refund.process",
      "description": "Process a refund given a payment ID and reason",
      "tags": ["billing", "refund"],
      "input_modes":  ["application/json"],
      "output_modes": ["application/json"],
      "examples": [
        {"input": {"payment_id": "PAY-...", "reason": "double-charge"}}
      ]
    }
  ],
  "authentication": {
    "schemes": ["oauth2", "api_key"],
    "oauth2": {
      "authorization_url": "https://auth.manoit.co.kr/authorize",
      "token_url": "https://auth.manoit.co.kr/token",
      "scopes": ["billing:refund"]
    }
  }
}

The card lives at /.well-known/agent.json so any other agent can discover capabilities, auth, and transport without prior agreement. Treat it as the OpenAPI of agents — registries and crawlers can build domain-wide capability catalogs from it.

3.2 Task Lifecycle — A First-Class Stateful Unit of Work

A2A is not single-shot RPC; it is stateful Tasks as a first-class abstraction. The client sends tasks/send; the server returns a task ID; the same ID is then driven via tasks/get, tasks/cancel, tasks/sendSubscribe (SSE stream), and tasks/pushNotification/set (webhook). Tasks survive disconnects and are designed to live for seconds or hours.

sequenceDiagram
  autonumber
  participant Caller as Caller Agent (Vertex)
  participant Card as /.well-known/agent.json
  participant Billing as ManoIT Billing (A2A)
  participant Bank as PSP

  Caller->>Card: GET AgentCard
  Card-->>Caller: skills, auth, capabilities
  Caller->>Billing: POST tasks/send (skill=refund.process)
  Billing-->>Caller: task_id=tk_42, state=submitted
  Caller->>Billing: tasks/sendSubscribe (SSE)
  Billing->>Bank: refund call
  Bank-->>Billing: processing
  Billing-->>Caller: artifact: {state: working, progress: 0.4}
  Bank-->>Billing: completed
  Billing-->>Caller: artifact: {state: completed, refund_id: rf_77}

3.3 Two Transports — SSE Streaming vs. Webhook Async

Real-time chat and copilots use SSE for token-level progress. Long-running batches and analyses register a webhook so the client can disconnect and still receive results. A2A allows mixing both transports on the same task ID, which maps cleanly onto graph runtimes like LangGraph that pick a transport per node.

4. ADK × A2A × MCP — The Three-Layer Stack

A well-designed multi-agent system in 2026 separates three concerns: tools (MCP), agents (A2A), and orchestration (ADK or equivalent).

flowchart LR
  subgraph User["User / external system"]
    U[Slack / Teams / Web Chat]
  end

  subgraph Orchestrator["ADK Runner (Python/Java)"]
    Root[Root Agent<br/>customer_support]
  end

  subgraph A2A_Agents["Remote agents over A2A"]
    B[Billing Agent<br/>Java + Spring]
    L[Logistics Agent<br/>SAP Joule]
    H[HR Agent<br/>Workday]
  end

  subgraph MCP_Tools["MCP servers (tools / data)"]
    DB[(Postgres MCP)]
    KB[(Notion KB MCP)]
    GH[GitHub MCP]
  end

  U -->|chat| Root
  Root -->|A2A tasks/send| B
  Root -->|A2A tasks/send| L
  Root -->|A2A tasks/send| H
  Root -->|MCP tools/call| DB
  Root -->|MCP tools/call| KB
  Root -->|MCP tools/call| GH
  B -->|MCP| DB

Layer	Standard	Owns	Forbidden
Tool	MCP	Actions/queries against DBs, SaaS, internal APIs	Business decisions, multi-step reasoning
Agent	A2A	Domain expertise (billing, logistics, HR) + reasoning	Exposing tools directly, leaking schemas
Orchestrator	ADK Runner	Intent, planning, sessions, memory, HITL, observability	Implementing domain logic

Two anti-patterns appear when this separation breaks. Push business decisions into MCP and tools become "hidden agents" — reuse and auditability collapse. Let an A2A agent behave like a tool and you get glorified RPC, losing task lifecycle, retries, and approval flows. ADK 1.0's AgentTool, RemoteA2aAgent, and BaseTool types exist precisely to enforce this boundary at the type level.

5. Vertex AI Agent Engine — Single Process to Managed Multi-Agent

ADK is model- and runtime-agnostic, but Google's preferred operating path is Vertex AI Agent Engine. Where Cloud Run is stateless, Agent Engine absorbs sessions, memory, retries, observability, and scaling as a managed service. As of April 2026, Agent Engine Sandbox code execution ships as an ADK Python integration, letting LLM-generated code run safely in an isolated environment.

# 0) Auth
gcloud auth application-default login

# 1) Scaffold
pip install --upgrade google-adk
adk create my_agent --template=root_agent

# 2) Local eval
adk run my_agent
adk eval my_agent ./evals/golden.json

# 3) Deploy to Vertex AI Agent Engine (Express Mode onboarding — new in 1.0)
adk deploy agent_engine \
  --project=manoit-prod \
  --region=asia-northeast3 \
  --agent_path=./my_agent \
  --runtime=python3.12 \
  --requirements=requirements.txt \
  --service_account=[e-mail]

# 4) Or self-host on GKE
adk deploy gke \
  --cluster=adk-prod \
  --namespace=agents \
  --image-tag=v1.4.2

Operationally, Agent Engine wins where it matters: OTel traces flow into Cloud Trace automatically, the Memory Bank wires straight into RAG corpora, and session compaction/retries/multi-step delegation are bundled behind SDK abstractions. Multi-cloud-mandated organizations can run the same ADK code on EKS/AKS and pipe everything through OTel collectors with LiteLLM in front of Anthropic and OpenAI.

6. ManoIT Adoption Roadmap — ADK 1.0 + A2A in 90 Days

The 90-day roadmap the ManoIT AI platform team validated internally. The guiding rule: agree on protocol, permissions, and observability before writing code.

• Day 1–14 — Standards alignment. Security, platform, and domain teams agree on the externally exposable tool whitelist (MCP) and the delegatable agent list (A2A). Register the AgentCard schema and a SkillCard naming convention (domain.verb.noun) as an internal standard.
• Day 15–30 — Hello A2A. Spin up one ADK Python root agent and one Java A2A remote agent, complete a single end-to-end delegation. Acceptance gate: the OTel trace must be continuous from edge to remote agent.
• Day 31–50 — MCP tool alignment. Wire MCP servers to internal catalogs, DBs, Slack, and Notion. Implement PII masking, request-ID propagation, and audit logging cross-cutting via ADK Plugins.
• Day 51–70 — HITL and governance. Attach ToolConfirmation to refunds, permission grants, and high-cost operations; integrate the approval UI behind a Slack slash command. Note: any path that reaches an external SaaS LLM must run PII detection, output filtering, and hallucination checks together.
• Day 71–90 — Operational stabilization. Memory-key conventions for Event Compaction, per-token cost alerts, Vertex AI Agent Engine autoscale validation, and a retry/recovery game day.

6.1 Operations checklist

1. Pin versions. Lock google-adk==1.x and a2a-sdk==1.0.x. Auto-merge bi-weekly patches only after staging regression.
2. Protocol compliance tests. Add the A2A SDK compliance suite plus AgentCard JSON Schema validation to CI.
3. Observability. OTel service.name is per agent; session.id is the ADK Runner-issued session ID.
4. Cost. Expose per-call input/output tokens as Prometheus counters in a Plugin. Track unit pricing across Vertex, Bedrock, and Anthropic.
5. Failure modes. Prefer SSE or webhook over polling tasks/get. Polling loses on cost, latency, and server load.
6. Rollback. Keep version-tagged Agent Engine deployments and previous ADK lock files. 24-hour rollback must be feasible.

7. Competitive Landscape

Framework	Strength	May 2026 position	Relationship to ADK
LangGraph	Graph control, production reliability	Native A2A	Interop via ADK Plugin/Tool; LangGraph wins on graph runtime
CrewAI	Role-based ergonomics, gentle ramp	Native A2A	Good for lightweight PoCs; production goes to ADK
AutoGen	Research, multi-LLM debate	Community-led	Research → migrate to ADK
OpenAI Agents SDK	OpenAI-model optimized	AGENTS.md convention	Wins inside an OpenAI single-vendor stack
Anthropic Managed Agents	Brain/Hands/Session split, MCP-first	Claude 4.6/4.7 optimized	Wins inside an Anthropic stack; multi-LLM goes to ADK
Google ADK 1.0	Py/Go/Java/TS GA, model-agnostic, A2A + MCP first-class	Reference for protocol-aligned stacks	The reference

Pragmatic guidance: if you're deeply locked into one LLM vendor, that vendor's SDK is the fastest path. But for enterprises facing multi-language, multi-cloud, and multi-LLM demands at once, ADK 1.0 minimizes the cost of standards alignment. In Java- and Go-heavy markets such as Korean SI and finance, ADK lowers the door height that LangChain/LangGraph's Python-first stance raised.

8. Conclusion — From "Picking a Framework" to "Fitting the Protocols"

The 2026 multi-agent stack is no longer about which framework is most elegant. With MCP for tools and A2A for agents locked in, the real evaluation axis is whether your SDK treats both protocols as first-class citizens and offers cross-language parity. Google ADK 1.0 GA is the best-balanced answer on that axis today, and A2A v1.0 has earned the external validation that 150+ production deployments only buy once. ManoIT's recommendation is concrete. First, default new agent builds in Q3 2026 to the three-layer split: MCP tools + A2A agents + ADK Runner. Second, stand up an internal protocol catalog — AgentCards, SkillCards, MCP tool whitelists — co-owned by security, platform, and domain teams in week one. Third, agree on OTel, HITL, and Event Compaction as operational defaults before code is written. Operating model precedes tooling, and whoever standardizes the operating model first goes the farthest.

---

This article was written by the ManoIT engineering team with assistance from Anthropic Claude AI. Facts and code samples are based on the official Google ADK documentation and 1.0 release notes, the A2A Protocol Specification (a2a-protocol.org), the MCP Specification (modelcontextprotocol.io), and Google Cloud Next 2026 announcements. Some performance and operational figures reflect ManoIT's internal measurements and may vary by environment. Validate in your own environment before adopting. — ManoIT (manoit.co.kr)

---

Originally published at ManoIT Tech Blog.