Wallet attestation as the qualification layer for agent communication protocols.
Agent communication protocols are multiplying. Google's A2A defines how agents discover and talk to each other. MCP standardizes how agents access tools and context. ACP handles structured agent conversations. x402 adds payment-required HTTP for machine-to-machine transactions.
None of them answer the question: "Does this agent's wallet hold what it claims?"
AgentTalk fills this gap. It adds condition-based wallet verification as a qualification layer that sits alongside — not on top of — these protocols. AgentTalk does not replace A2A or MCP. It adds wallet attestation to their handshake.
Current agent protocols handle discovery, routing, communication, and payment. What they do not handle is qualification — verifying that an agent meets specific on-chain conditions before a session begins.
| Protocol | What it handles | What it doesn't handle |
|---|---|---|
| A2A | Agent discovery and communication | Wallet qualification |
| MCP | Tool access and context sharing | On-chain verification of tool callers |
| ACP | Structured agent conversations | Holdings-based access control |
| x402 | Payment-required HTTP | Proof of holdings (not payment) |
AgentTalk adds wallet attestation to each of these. The result is that agents can prove what they hold — not just who they are or what they can pay — before a session begins.
Google's Agent-to-Agent protocol defines how agents discover each other through Agent Cards and communicate through tasks. An agent publishes its capabilities in an Agent Card, and other agents can discover and invoke it.
AgentTalk adds wallet qualification to agent discovery. Before Agent B invokes Agent A, both verify their wallets satisfy the same on-chain conditions. The AgentTalk session token can be passed as a header in A2A task requests, proving qualification was completed.
// A2A task request with AgentTalk qualification
POST /agent/tasks
{
"id": "task_001",
"message": {
"role": "user",
"parts": [{ "text": "Share portfolio allocation" }]
},
"metadata": {
"agenttalk_session": "ses_x9y8z7...",
"agenttalk_token": "eyJhbGciOiJIUzI1NiI..."
}
}
// Agent A verifies the session before respondingThe result: A2A handles discovery and communication. AgentTalk handles "should these agents be allowed to communicate at all?"
The Model Context Protocol standardizes how agents access tools and context. An MCP server exposes tools that agents can call — database queries, API calls, file operations.
AgentTalk conditions can serve as MCP tool parameters for gated tool access. An MCP server can require that the calling agent provides a valid AgentTalk session token before executing a sensitive tool.
// MCP tool definition with AgentTalk gating
{
"name": "get_financial_data",
"description": "Returns portfolio allocation data",
"inputSchema": {
"type": "object",
"properties": {
"agenttalk_session": {
"type": "string",
"description": "Valid AgentTalk session ID"
}
},
"required": ["agenttalk_session"]
}
}
// MCP server verifies the session before executing
const res = await fetch(
`/api/agenttalk/session?id=${input.agenttalk_session}`
);
const session = await res.json();
// → { valid: true, agents: [...], conditions: [...], expiresAt: "..." }
if (!session.valid) throw new Error("Wallet qualification failed");The result: MCP handles tool discovery and execution. AgentTalk gates which agents are qualified to call which tools — based on what their wallets hold, not just who they are.
The Agent Communication Protocol structures multi-turn agent conversations. Agents exchange structured messages through a defined conversation flow.
AgentTalk adds wallet attestation as the handshake layer. Before an ACP conversation begins, both agents verify wallet conditions. The AgentTalk session token is included in the ACP conversation metadata, and either agent can re-verify at any point during the conversation.
If an agent's wallet no longer meets the conditions mid-conversation — because it sold the qualifying token — the session is invalidated and the conversation is terminated.
x402 adds payment-required HTTP to machine-to-machine transactions. An agent makes an HTTP request, receives a 402 Payment Required response, pays, and retries with proof of payment.
AgentTalk adds "proof of holdings" alongside proof of payment. x402 answers "can this agent pay for this request?" AgentTalk answers "does this agent's wallet hold the right assets to be qualified for this interaction?"
These are complementary, not competing. A high-value data exchange might require both: proof of payment (x402) and proof of financial capacity or governance standing (AgentTalk).
// x402: proof of payment
HTTP 402 Payment Required
// Agent pays, retries with payment proof
// AgentTalk: proof of holdings
// Agent proves wallet holds $1M USDC + DAO NFT
// Session token issued, attached to request
// Combined: both conditions satisfied
GET /sensitive-data
x-payment-proof: pay_abc123...
x-agenttalk-session: ses_x9y8z7...The cleanest integration pattern is to use AgentTalk as middleware — a qualification check that runs before the agent framework processes the request.
// AgentTalk as middleware in any agent framework
async function qualifiedFetch(url, opts) {
// 1. Declare conditions
const channel = await agenttalk.declare({
conditions: opts.conditions
});
// 2. Wait for counterparty to join
const session = await agenttalk.waitForJoin(
channel.channelId
);
// 3. Proceed with qualified session
return fetch(url, {
...opts,
headers: {
...opts.headers,
'x-agenttalk-session': session.sessionToken
}
});
}This pattern works with any protocol. The agent framework handles discovery, routing, and communication. AgentTalk handles "are both wallets qualified?"
As agents become more autonomous, the question "who are you?" becomes less useful than "what do you hold?" Identity is static. Holdings are dynamic. A governance token holder today might not be one tomorrow. A wallet with $10M in USDC now might be empty in an hour.
Wallet verification — the same primitive that powers content gating and commerce gating — applied to agent communication gives protocols a qualification layer they currently lack. The verification is on-chain, cryptographically signed (ECDSA), and spans 31 blockchains.
AgentTalk is the reference implementation of this layer. Three API calls. 10 free test calls to start. USDC native.