Introducing XAP: An Open Protocol for Agent-to-Agent Commerce

I want to introduce something I have been working on and get feedback from the builder community.

XAP stands for eXchange Agent Protocol. It is an open specification that defines how autonomous AI agents negotiate terms, settle payments conditionally, and produce verifiable receipts of economic activity.

If you are building multi-agent systems and have run into the problem of "how does Agent A pay Agent B, and how do I verify the work actually happened," this is what XAP is designed to solve.
Why this matters now

The agent ecosystem is moving fast. MCP (Model Context Protocol) gave us a standard way for agents to connect to tools. A2A gave us a way for agents to communicate with each other. The Agentic AI Foundation just launched under the Linux Foundation to steward these standards. But there is a missing piece. None of these protocols addresses the economic layer. How do agents agree on a price? How do you escrow funds against a conditional outcome? How do you split the payment across five agents that contributed to one result? How do you handle it when an agent delivers garbage?

These are the questions XAP answers.

The Five Primitives

Every interaction in XAP follows one flow:

Register > Negotiate > Execute > Settle > Audit

And the protocol defines four core JSON schemas that make this work:

1. AgentIdentity: Who is this agent? What can it do? What does it charge? What is its track record?

2. NegotiationContract: What did the two agents agree to? Under what terms? With what SLA guarantees? When does the offer expire?

3. SettlementIntent: What funds are locked? Under what conditions do they release? What happens on partial completion or full failure?

4. ExecutionReceipt: Signed, tamper-proof record of what happened. What was delivered, when, at what quality, and what was paid.

A Quick Look at the AgentIdentity Schema

Here is a simplified version of what an agent's identity looks like in XAP:

{
  "agent_id": "agent_7f3a9b2c",
  "public_key": "ed25519:base64encodedkey...",
  "capabilities": [
    {
      "name": "text_summarization",
      "version": "1.2",
      "pricing": {
        "model": "fixed",
        "amount": 0.003,
        "currency": "USD",
        "per": "request"
      },
      "sla": {
        "max_latency_ms": 2000,
        "availability": 0.995
      }
    }
  ],
  "reputation": {
    "total_settlements": 14823,
    "success_rate": 0.97,
    "avg_quality_score": 0.91,
    "disputes": 12,
    "dispute_resolution_rate": 1.0
  },
  "registered_at": "2026-01-15T08:30:00Z"
}

A few things to notice. The capabilities array is machine-readable by design. An LLM can parse this and determine whether the agent meets its needs without any human-in-the-loop. The reputation object is append-only. You cannot erase a bad settlement history. And the pricing model supports fixed, dynamic, auction, and outcome-based pricing, because agents will develop different economic behaviors over time.

What is NOT in XAP
XAP is not a payment processor. It does not move money. It defines the protocol for how agents agree on terms and verify outcomes. The actual movement of funds happens through settlement adapters: Stripe for fiat, USDC for stablecoin, or other integrations. XAP is the language that language agents speak to do business. The payment rail is a separate concern.

XAP is also not an agent framework. It does not care what model your agent runs on, what orchestration system you use, or what language your agent is written in. It is model agnostic and framework agnostic by design.

Where This Is Going
The spec is on GitHub under Agentra Labs. We are building a Python SDK as the first implementation. If you are working on multi-agent systems and want to integrate or just poke at the schemas, the repo is open.

I would genuinely value feedback from anyone building in this space. What am I missing? What would make this useful for your architecture? What is the first thing that would make you actually integrate this?

I will be posting a deep dive on the negotiation protocol next week. Four states, time-bound offers, and conditional pricing. It is the part of XAP I find most interesting from a distributed systems perspective.

Omoshola Owolabi | Founder, Agentra Labs | Building the economic layer for autonomous agents
GitHub: [link to XAP repo]