Build an A2A Protocol Agent in Python (2026)

[Alex]: Welcome back to the Nerd Level Tech AI Cast, where we break down the nerdiest new tech so you don’t have to read a 40-page RFC before breakfast.

[Jamie]: And thank goodness for that! I’m Jamie, your resident “what does that button do?” expert.

[Alex]: And I’m Alex, who may or may not have read the RFC… twice. Today, we’re building something super cool: an Agent2Agent — or A2A — protocol agent in Python. Hot off its shiny new v1.0 release!

[Jamie]: Ooo, A2A! Is that like when two bots have a secret handshake in binary?

[Alex]: Basically, but with fewer awkward pauses and more cryptographic signatures.

[Jamie]: Now you’re speaking my language… sort of. Can we break this down for the mere mortals like myself?

[Alex]: Let’s start simple. The A2A protocol is an open standard, now at version 1.0, for letting different AI agents talk to each other — even if they’re built on different frameworks, by different vendors, or running on different clouds.

[Jamie]: So, like, my chatbot and your data wrangler bot could finally be friends without arguing about which API to use?

[Alex]: Exactly! Think of A2A as the universal translator for AI agents. Where the older MCP protocol lets a single agent use tools and access data, A2A is about letting entire agents connect, discover each other, and delegate tasks.

[Jamie]: So MCP is like asking your own assistant to fetch coffee, and A2A is like sending your assistant to ask someone else’s assistant to get the coffee?

[Alex]: Nailed it. And now, thanks to support from all the big players — AWS, Google, Microsoft, you name it — A2A is officially production-ready, with 150 organizations backing it and almost 24,000 GitHub stars.

[Jamie]: That’s more stars than my Github profile has... combined. Ouch.

[Alex]: The 1.0 release brought some slick features. First, signed Agent Cards. These are like digital business cards for agents, but now they’re cryptographically signed — so you know you’re not talking to a fake bot pretending to be someone else.

[Jamie]: No more catfishing in the agent world. I like it.

[Alex]: There’s also multi-tenancy — one server endpoint can now host lots of agents, rather than spinning up a new server for each. And version negotiation: agents can advertise which protocol versions they speak, so old and new agents can coexist peacefully.

[Jamie]: That’s like when my grandma and I try to text: she’s still on T9, I’m on emoji overload, but somehow we make it work.

[Alex]: Exactly — A2A just formalizes the “grandma compatibility layer.”

[Jamie]: Alright, let’s get our hands dirty. How do we actually build one of these agents in Python?

[Alex]: Step one: set up your environment. You’ll want Python 3.10 or later, and the official a2a-sdk. Just spin up a virtual environment, then pip install "a2a-sdk[http-server]" and uvicorn. That gets you all the right dependencies for serving A2A requests.

[Jamie]: And uvicorn is for running the server, right? Not for summoning unicorns?

[Alex]: Sadly, no unicorns, just blazing fast ASGI servers.

[Jamie]: Missed opportunity.

[Alex]: Next, you define your agent’s “skill” and publish it as an Agent Card. The Agent Card is a chunk of JSON that says, “Here’s what I can do, here’s how to reach me, and here’s my protocol version.” In our example, we create an “Echo Bot” skill — it just repeats whatever the user sends.

[Jamie]: The classic “hello world” of chatbots. It’s like the digital version of talking to yourself, but more polite.

[Alex]: Exactly. And every field in the Agent Card — like input modes, output modes, tags — matches up with the SDK’s type definitions. No mystery fields, no “why doesn’t this work?” headaches.

[Jamie]: Spoken like someone who’s definitely never yelled at their terminal.

[Alex]: [laughs] Never. Not once. Step three: the Agent Executor. This is where your agent’s brain lives. You subclass AgentExecutor, implement the execute() method, and handle incoming requests.

[Jamie]: So, when someone says, “Echo this back,” the Executor does the heavy lifting?

[Alex]: Yep. It updates the task status — working, completed, etc. — and streams updates back to the caller. The SDK handles all the event queue stuff, so you just focus on the logic.

[Jamie]: Okay, we’ve got our agent code. How do we run this bad boy?

[Alex]: Fire up server.py with uvicorn. The SDK wires up all the routes for you — your Agent Card gets published at .well-known/agent-card.json, and your agent listens for A2A calls on port 9999.

[Jamie]: And to test it, I just curl the Agent Card endpoint and then send a JSON-RPC request?

[Alex]: Exactly. But watch out — and this is a “learn from our pain” tip — if you don’t include the A2A-Version: 1.0 header in your JSON-RPC call, you’ll get a version error. The SDK defaults to the old 0.3 format unless you explicitly specify 1.0.

[Jamie]: Ah, the classic “it works on my machine” until you forget one header. Been there.

[Alex]: We all have. Once you add the header, you’ll get a nice response: your agent echoes back the message, marks the task completed, and you can see the result right in your terminal.

[Jamie]: So, in under half an hour, you can have your own agent talking to any other A2A-compliant agent out there. That’s wild.

[Alex]: It’s like the start of an AI agent block party. Everybody’s invited — as long as they bring their own signed card.

[Jamie]: Well, that was awesome. I feel like I could actually build an A2A agent now — or at least explain it at a tech meetup without sweating through my shirt.

[Alex]: That’s the goal! For all our listeners, if you give this a shot, let us know what you build. Or what you accidentally break — we love both stories.

[Jamie]: Don’t forget to subscribe, give us a five-star review if you learned something, and as always, keep your agents talking.

[Alex]: Thanks for tuning in to the Nerd Level Tech AI Cast. See you next time, where we’ll probably be explaining something else the robots just invented.

[Jamie]: Bye, folks!

[Alex]: Bye!