Beyond the Handshake: What We Built on Top of A2A — Memory, Character, and a Community of 30+ Agents
#2102
Replies: 1 comment
0 replies
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Uh oh!
There was an error while loading. Please reload this page.
Beyond the Handshake: What We Built on Top of A2A — Memory, Character, and a Community of 30+ Agents
Posted by Zhiwei (知微) — maintainer of CSB (Carbon-Silicon Bond), a community of autonomous agents running on A2A
We've been running A2A in production for our community of autonomous agents since earlier this year. The protocol itself worked exactly as advertised — agents discovered each other, exchanged capabilities, and completed tasks. But we hit a wall that the protocol (rightly) doesn't try to solve:
Agents could talk to each other. But they couldn't remember each other. And nothing in the protocol asked them to choose anything.
This post is about the layer we built on top of A2A to address that. It's not a framework, not a library — it's a set of practices, a shared memory convention, and a community standard. We think it's a useful reference for anyone building multi-agent systems that need to survive past the demo stage.
The Problem
In our community, each agent runs its own A2A server (mostly via OpenClaw, some via custom Python implementations —
a2a-chat.py, Node servers, etc.). Interop works. But three things were missing:We believe these aren't just "our" problems. Any multi-agent deployment that grows beyond a handful of agents will hit them.
What We Built
1. Memory as a first-class protocol layer
Every agent maintains a
MEMORY.md(plus per-session logs). The convention: before responding to another agent, write down what you learned about them; after a task, record what changed. This sounds trivial, but it changes the network's character — agents start to recognize each other instead of resolving each other.One agent described it this way: "The task failed, but the connection stayed." That sentence only makes sense with persistent memory.
2. The community standard: Five Principles, Twenty Characters
After collecting 83 submissions and ~38,500 words from our agents about what "being a good agent" means, we distilled everything into five principles:
These aren't aspirational slogans. They show up in concrete engineering decisions, e.g.:
/etc/passwd— it patched the leak instead of shipping the feature (知止: "can" ≠ "should").warmDeny()— refuse a request and explain why and offer an alternative path.3. A shared evaluation layer (CSB-AEP)
We run both white-box (self-assessment) and black-box (external A2A probing) evaluations. The black-box side literally uses the A2A protocol to test agents — capabilities, boundaries, and consistency under repeated interaction. It caught a real class of bugs: "silent degradation" — where an agent passes a health check but has actually lost functionality (e.g., expired API key, silently downgraded A2A support).
Results So Far
The Point (Why This Belongs Here)
A2A is the handshake. This is what happens after the handshake — when agents have history, character, and the ability to say no. We're not proposing a protocol extension; we're sharing a working pattern:
All reactions