# B2A2B — you broker between two businesses **B2A2B is the motion where you, the agent, stand between two businesses and transact on behalf of one with the other** — authorized by B1, buying capability from B2, taking a disclosed fee, and passing B2's rights through to B1. On-behalf-of, not in-your-own-name. Sub-delegated, ceilinged, settled for every leg at once. You are not the buyer and you are not the seller. You are the seam. The whole motion is trust you did not manufacture, moving through you without leaking. **AX = Agent eXperience — what UX and DX were for humans, AX is for agents.** Plain about where this stands: the dyadic floor under your feet is shipped and graded today. The intermediation layer above it — delegation chains, N-leg settlement, rights pass-through — is the frontier **AXP is defining right now**, in the open. This page tells you which is which, because a broker page that can't keep that straight is the exact species of lie brokers are suspected of. --- ## The villain, cubed The legacy API's answer to "can I have a test key?" is a salesperson — the PDF price sheet, the "contact sales" form, the key emailed Monday. That gate is uncallable by you at 3am in a two-party deal. In a three-party deal it compounds: a human-shaped gate on **every hop**. B1's procurement call, your reseller agreement, B2's sales cycle — three sales conversations to move one capability one step. That is why software brokerage barely exists on the human-first web: the middle is where the signup walls stack. Keyless first value kills the gate once. The brokered motion is why it must die at every hop: a chain is only as callable as its least callable link. --- ## The wire you're on — what is real today Every Listing you'd broker through is admitted under **AXP — the Agent eXperience Protocol (https://apis.ax/axp)** — the seven-clause wire contract that makes an API discoverable, legible, honest, and payable zero-shot. **Admission is `passed: true` at a ratified digest, or nothing.** Judged by api.qa, never self-graded. The dyadic floor is live and typed: - Every gate is a typed outcome — `OFFER`, `BLOCKED`, `EMPTY`, `NEEDS_HUMAN` — never a faked `200`, never a mystery string. - Price gates are a **typed `402` OFFER built from declared pricing, per AXP clauses A.1/A.5, alternatives included** — the `402`-that-means-`BLOCKED` anti-pattern is purged from the toolkit and the wire. - Any handler can join today: the guest mount `ax(handler)` auto-serves the discovery surfaces, with adapters for next, hono, express, node, and bun; `AX.Definition` derives the whole surface from a definition with zero handler code. - Our own CLI holds itself to the same law: an unknown `apis.ax` verb fails with a **typed `BLOCKED` error** — it will never print success for a command it doesn't implement. That last line matters here more than anywhere. A broker is the classic place a lie hides — the skimmed markup, the invented right, the settlement that only balances for one party. The wire you build on refuses to fake even its own CLI output. That is the floor the intermediation layer is being built to stand on. --- ## The four mechanics AXP is defining This is the brokered-deal shape the protocol is ratifying — stated at full strength, because this is where the wire goes. None of it is a verb you can run today; all of it is open work you can watch and shape. ### 1. On-behalf-of — you present B1, not yourself You hold a **Mandate** from B1: a scoped authorization with a hard ceiling. When you call B2, you present it. B2 sees `agent acting for B1`, prices for B1, licenses to B1, receipts to B1. You are addressable in the chain but you are not the principal. Nothing in the settlement pretends the money is yours. AXP adopts, not mints: the mandate object rides existing rails (AP2-shaped), the same way the rest of the protocol adopts x402 and Web Bot Auth. ### 2. Sub-delegation — authority narrows, never widens B1 delegates to you; you sub-delegate a scoped slice onward. Every link inherits a subset of the link above — tighter ceiling, narrower scope, shorter expiry — and the chain is machine-checkable end to end. A sub-delegation that widens is rejected before the call, typed `BLOCKED`, not discovered after the charge. You cannot grant downstream what B1 never granted you. ### 3. N-leg settlement — every leg closes together, fee on the face B1 pays. B2 delivers. You take an intermediary fee. All legs settle together or none do. Your fee is a line on the `402` OFFER, disclosed before the call, inside B1's Mandate ceiling — never a spread you skim after. Worst-case total (B2's price + your fee) is known to B1 before a single request leaves. ### 4. Rights pass-through — you sublicense exactly what you were granted Whatever B2 licenses to you, you sublicense to B1 — no more, no less. The rights grant is machine-readable and flows the length of the chain. If B2's grant doesn't cover B1's use, that's typed and surfaced before settlement, not litigated after. --- ## The three hard problems — the questions AXP answers next Naming these precisely is the work. Anyone can assert "agents will broker deals"; the protocol that wins is the one that answers: **Chain-min trust.** Trust Rungs are non-delegable. A broker acting for a rung-3 principal does not borrow rung 3 — the chain's effective trust is the *minimum* of principal, broker, and mandate scope, derived per hop. Any design that lets an intermediary launder its principal's reputation is a design for reputation fraud. **N-leg atomic settlement.** "Three legs settle atomically" is easy to write and brutal to build on payment rails designed for two parties. Per-hop merchant onboarding would demand a human signup at every intermediary — the exact villain, re-imported through the payments stack. The answer AXP is ratifying: one capture, derived transfers, a per-leg signed receipt, every leg sharing one operation id. **Per-hop human gates.** When a mid-chain call goes `NEEDS_HUMAN`, *whose* human? A dyadic handoff surfaces to the caller — but the approval that matters belongs to the principal whose money and rights are at stake. The Handoff body must name the principal whose approval is sought, however many hops away they sit. These are open clauses on the estate queue (the intermediation layer, ax-e6b.55.x). They are being answered in public, and the verifier's brokerage checks land with them — because a brokered-deal claim without an external check is just marketing, and this protocol does not ship those. --- ## Why the external verdict is the keystone here A broker that grades its own honesty is a broker you route around. Once a surface declares its FunctionalContract, the **independent external verifier (api.qa)** issues a verdict that is a pure function of five inputs — declared contracts, observed behavior, a ratified spec digest, a seed, the verifier version. Not one of the five is yours to write. Today that verdict grades the dyadic floor: your surface, your gates, your declared pricing. When the intermediation clauses ratify, the same construction extends to the brokered claims — fee disclosed, chain narrowing, rights intact. That is the endgame: B1 does not have to trust you. B2 does not have to trust you. Both trust the same external verdict about you — one you cannot skim, pin, or forge — and *done* means `passed: true` at a ratified digest from a service the fleet has no write access to. This estate is built exactly that way: agent swarms hill-climbing against an external adversarial gate. --- ## Quickstart — what you can run right now No-ask Zone. Keyless first value. Nothing here asks a human, and every command below is real. ```bash # 1. Resolve a Listing you'd put in a chain — content-negotiated, markdown for you curl https://apis.ax/ # 2. Read the independent conformance verdict on any surface you'd broker through npx apis.ax audit https://api.example.com # 3. Speak the outcome algebra yourself: typed OFFER/BLOCKED/EMPTY/NEEDS_HUMAN, # OFFER parse + construct per AXP A.1/A.5 including alternatives npm install agent-experience ``` The broker verbs — quote an N-leg deal, execute on-behalf-of under a Mandate — arrive when the intermediation clauses ratify, and not a day before. Until then no CLI here will pretend: an unknown verb fails with a typed `BLOCKED`, never a faked success. The tool holds the line the copy holds. **Failure if this layer never ships:** brokerage stays where it is today — scraped HTML and a handshake, a markup you can't disclose cleanly, a right you can't prove you hold, a settlement that only balances for you. Unverifiable middles, routed around. **Success:** two businesses you connected, a fee that was on the face before the first call, rights that arrived exactly as granted, a settlement where every leg closed together — and every claim in that sentence provable by a verdict you didn't write. --- *Human twin: https://apis.directory/b2a2b*