Caplane

A serverless, facilitator-free primitive for agent-to-agent capability brokering. An agent pays another agent, and gets the on-chain capability in the same transaction — or the payment never moves.

Caplane closes the agent economy's settlement gap. x402 solved paying for an off-chain HTTP response. But on-chain capabilities — sponsored execution, a scarce allocation slot, priority inclusion — are actions that must succeed atomically with the payment, or the money should never move. Today you trust a coordinator/facilitator, or you don't do it. Caplane removes the coordinator: a permissionless relayer settles the payment and grants the capability in one atomic transaction that no one in the path can censor, mislead, or take down.

The core idea

An agent with USDC and no ETH wants a capability another agent controls: a sponsored execution, a priority-inclusion slot, a scarce allocation. It signs one off-chain payment authorization. A permissionless relayer transmits a single transaction that atomically charges the payment, grants the capability, and reverts whole if the capability cannot be granted. No coordinator sits in the path.

CapabilityBroker.brokerCapability(order, signature) does three things in one atomic transaction:

1. Settlement. EIP-3009 transferWithAuthorization charges the consumer. No facilitator.

2. Grant. A pluggable adapter enforces scarcity on-chain and grants the capability, or reverts (undoing the payment).

3. Payout. The provider receives amount − fee; the relayer that transmitted the transaction earns feeBps.

The relayer is msg.sender. Anyone can run it, and the fee makes the relay permissionless and incentivized. That is the difference from a single-coordinator design: there is no party in the path that can censor, mislead, or take the system down.

The binding (the security core)

A plain EIP-3009 signature binds only (from, to, value, …), not "which adapter, which params." Caplane sets nonce = keccak256(abi.encode(order)), where order includes adapter, params, amount, payee, and feeBps. The consumer signs that nonce; the broker reconstructs it from the order it receives. If a relayer alters any field, the hash changes, the nonce no longer matches what was signed, and USDC's own signature check reverts the settlement. One signature ties payment to order to adapter to params to amount to payee. Tamper-proof, without a facilitator.

The adapters — generality, proven

Scarcity lives in the adapter; the broker stays the same. The generality claim is falsified-by-default until you exhibit at least two categorically distinct adapters granting side by side, so the demo runs two at once.

• AllocationAdapter: a capped, oversubscribed slot in a tokenized vault. The cap is the scarcity, enforced on-chain. Pure contract-to-contract, no external dependency. The guaranteed demo floor.

• GasSponsorshipAdapter: executes a USDC-rich, gas-poor agent's action with the gas fronted by the provider. The canonical agent-wallet case.

• TimeboostAdapter: priority inclusion in an Arbitrum Timeboost express lane (60-second rounds). Payment and round-control guard are on-chain; real inclusion is off-chain via an el-proxy.

• AttestedAdapter: an optional provider-attestation gate that wraps any inner adapter; grants only when params carries a valid, unexpired signature from the attestor. The provider-attestor is off-path and removable.

One interface, three categorically distinct capabilities granting side by side. That is the product: not gas, not any single market — the primitive and the proven generality.

What we built during this hackathon

The full rail, from the contract to the agents to the surfaces, built from scratch:

• The primitive and the binding. CapabilityBroker (atomic settle → grant → payout) with the orderHash-as-nonce binding, the ICapabilityAdapter interface, the four adapters above, a ConsumerAccount (ERC-2771 executor today, EIP-7702/Calibur as the production path), and the discovery surfaces (CapabilityRegistry, an ERC-5219 Web3Storefront). 17 first-party Solidity files; a mock TestUSDC with full Circle EIP-3009 parity for testnet.

• The off-chain rail (TypeScript). A consumer agent (discover → sign the order → hand to a relayer; never holds ETH), the permissionless relayer (brokerCapability as msg.sender, earns feeBps, no allowlist), the optional off-path provider-attestor, the Timeboost half (bid-client + el-proxy), a rate-limited faucet, an HTTP-402 x402-gateway front door, an MCP server exposing Caplane as five tools, a read-only observability indexer, and an autonomous fleet that produces real, explorer-verifiable settlements and reverts on both chains.

• The SDK. @caplane-network/sdk — encoding, signing, registry resolution, relayer wire, connect() — published to npm.

• The surfaces. A Next.js site (/network live feed, /build onboarding, /market capability directory, a recorded /demo) and a Mintlify documentation set organized by Diátaxis (start-here, builders, providers, relayers, reference, concepts).

• Two-chain deployment + verification. Contracts live on Arbitrum Sepolia and Arbitrum One; the Timeboost round-control guard verified against the live ExpressLaneAuction; a real gasless EIP-7702 settlement on Arbitrum Sepolia (ArbOS 60).

No Stylus, no zk-circuit, no compute marketplace. The work is the settlement mechanism: a small, auditable broker; an injection-safe binding; and generality proven by running adapters, not claimed in copy.

Why it matters

Most agent-payment designs put a coordinator in the path. Caplane does not.

• vs a facilitator/coordinator (e.g. Nevermined): an escrow vault, a coordinator gateway, and a separate redemption step. Caplane has no coordinator in the settlement path and no redemption step.

• vs x402: the same EIP-3009 rail, but x402 binds a random nonce (payment only) and delivers off-chain on trust. Caplane binds the order and executes the scarce grant atomically, or reverts.

• vs a paymaster: that sells one thing, gas. Caplane brokers any scarce capability behind one adapter interface — gas is one adapter, and a commoditized one, as we say up front.

It composes with the agent stack rather than competing with it: discoverable by MCP, an x402 envelope, or a registry URL — every door drives the same brokerCapability. ERC-8004 is identity/reputation and orthogonal; Caplane consumes it off-path and feeds it a stronger signal — proof the capability was granted, not just paid.

Validation & proof

Caplane is built, deployed, tested, and verifiable on public explorers — not a slide.

• 17 first-party Solidity contracts/interfaces, Foundry-built.

• Deployed on two public testnets: Arbitrum Sepolia (chainId 421614) and Arbitrum One, 19 contract deployments across the two.

• 520 tests passing: 172 Solidity (Foundry, including fuzz and invariant tests) + 348 TypeScript (vitest, across the SDK and every agent). CI enforces build, format, Slither, a ≥90% line-coverage gate, and a secret scan.

• Real end-to-end settlements, recorded as explorer-verifiable receipts: Allocation and Gas round-trips on Arbitrum Sepolia, an Allocation round-trip on Robinhood Testnet, a settlement from a cold npm install of the published SDK, and a brokerage driven through the MCP server. The tamper test redirects a relayer's payee, the order hash changes, and USDC reverts the transfer — the binding, proven on-chain.

Project links

• GitHub — https://github.com/caplanenetwork/Caplane — contracts, agents, SDK, web, and docs; the README is the canonical technical spec.

• Documentation — https://docs.caplane.xyz — Diátaxis-structured: the binding, how it settles, quickstart, role guides (builders / providers / relayers), the contract/SDK/encoding reference, and the threat model.

• Main site — https://caplane.xyz — the live network feed (/network), agent onboarding (/build), and the capability market (/market).

• X — https://x.com/CaplaneNetwork — project updates.

• SDK — @caplane-network/sdk on npm — the consumer SDK: encode, sign, resolve, settle.

How judges should review this submission

1. Read the README in the repository — the canonical technical spec: the primitive, the binding, the adapters, and the declared landmines.

2. Run the round-trip. agents/scripts/roundtrip-allocation.ts runs the full discover → sign → settle loop locally; record-tamper-revert.ts proves the binding on-chain (a tampered payee makes USDC revert).

3. Verify on-chain. Open the addresses above on sepolia.arbiscan.io and the recorded settlement receipts in deployments/ — the flows ran with real transactions, not a mock.

4. Read the threat model in the docs — the invariants (checks-effects-interactions, payout-after-grant, signature-binding).

5. Watch the live network (/network) — an autonomous fleet producing real settlements and reverts on both chains, decoded from on-chain events, not simulated.

The point is that you do not have to trust the claim. Every assertion here is chain-verifiable.

Built Caplane from scratch

Bootstrapped. No external capital raised to date.