Your awdk Agent Already Speaks A2A

Your awdk Agent Already Speaks A2A

Build an agent here, drop it into any A2A infrastructure — no account, no portal, no lock-in

By the Aitherium team — July 2026

---

There's a quiet anxiety that comes with picking an agent framework: am I locking myself in? You wire up tools, memory, a personality, a whole workflow — and then a partner shows up running Google's A2A, or a customer's platform is built on LangGraph, and you wonder how much of your work you're about to throw away to integrate.

Here's the good news, and it's the whole point of this post: an agent you build with awdk is already a standard A2A server. Not "A2A-compatible with an adapter." Not "A2A on our roadmap." The Agent2Agent protocol is the wire format an adk agent speaks. Any A2A-compliant client can discover it and drive it, and your adk agent can turn around and call any other A2A agent — Google's, a LangGraph server, a CrewAI crew, or a bare curl.

What that actually means

When you mount an adk agent, you get the standard A2A surface for free:

• Discovery — GET /.well-known/agent-card.json returns a spec-shaped Agent Card: name, description, URL, version, capabilities, skills.
• Messaging — POST /a2a speaks JSON-RPC 2.0: message/send, tasks/get, tasks/cancel.
• Streaming — Server-Sent Events at /a2a/tasks/{id}/subscribe for long-running tasks.

None of that requires an Aitherium account, an API key, or our portal. Talking to an agent needs no Aitherium auth at all. The Aitherium-specific pieces — signed peer trust, the fleet registry, letting a remote peer execute your local tools — are opt-in extensions layered on top. The interop core is pure spec.

The ten-line version

from fastapi import FastAPI
from adk import AitherAgent, A2AServer, tool
from adk.tools import get_global_registry

@tool
def add(a: float, b: float) -> str:
    "Add two numbers."
    return str(a + b)

agent = AitherAgent("aither", tools=[get_global_registry()])   # BYO model — Ollama by default
app = FastAPI()
A2AServer(agent=agent, base_url="http://localhost:8080").mount(app)

Run that under uvicorn and any A2A stack on earth can now do this:

curl http://localhost:8080/.well-known/agent-card.json

curl -X POST http://localhost:8080/a2a -H 'content-type: application/json' -d '{
  "jsonrpc":"2.0","id":1,"method":"message/send",
  "params":{"message":{"role":"user","parts":[{"type":"text","text":"hi"}]}}}'

The reverse works too. Point your adk agent at someone else's Agent Card URL and call them with the same message/send — vendor-neutral, no matter what framework is on the other end.

We didn't just claim it — we proved it

Claims about interop are cheap, so we wrote a self-test that drives an adk agent with a plain JSON-RPC client (just httpx, no adk SDK on the client side, no open port, no model) over an in-process transport. It asserts the card shape, a full message/send round-trip, and the tasks/get lifecycle — and it passes with zero Aitherium headers. It runs offline in CI in about a second:

card: name='echo-bot' standard_fields=['name', 'url', 'version', 'capabilities', 'skills']
message/send: state=completed reply='echo: hello from a plain A2A client'
tasks/get: round-tripped=True
RESULT: PASS

That's the entire claim, checkable in one command. It ships in the repo as interop_selftest.py.

Bring your own everything

Every example runs on a local Ollama by default — no keys, no caps, no metering. Point it at anything else with an env key (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, GROQ_API_KEY, …) or a --backend flag. Local and BYO backends are never metered; caps only ever apply to Aitherium's optional hosted gateway. Your agent, your model, your infrastructure.

And when you do want more

The extensions are there when you need them, and as of awdk 2.28.0 they include real dynamic trust: agents advertise their Ed25519 public key at registration, and a receiving agent resolves whether to trust an inbound signed request against an authoritative fleet directory — fail-closed, no static allowlists to hand-maintain. That's how you safely let a peer run your tools remotely (skills/invoke), which is the one method that requires a trusted signature. Everything else stays open.

Start building

We shipped a set of copy-paste recipes under examples/a2a/ in awdk:

• serve_standard_a2a.py — expose your agent as an A2A server.
• call_any_a2a_agent.py — call any external A2A agent by its card URL.
• sick_agent.py — the full pattern: typed tools + persistent memory + BYO model, served over A2A.
• interop_selftest.py — the offline proof; run it, watch it pass.

pip install -U awdk

Build the agent you actually want. It'll speak the same language as everyone else's.