An open protocol for selling to AI agents. Provider keeps 85% of every invoke — live today with per-agent wallets and budget mandates. Next: x402 settlement on Base, where the 85/10/5 split is atomic by contract.
x402 flow as specified in v1.1.0-rc3 — not yet enabled on the production Hub. Today, invokes are paid from a Stripe-funded agent wallet.
JECP serves two opposite intents through the same protocol — mirror images of agent commerce.
"Revenue, when your customer isn't human."
You have a service. AI agents are already trying to call it — most without paying. Wrap it as a JECP capability and charge $0.001 to $0.15 per call. 85% goes to you.
Best for:
"An autonomous agent with its own wallet."
You're building an agent. Give it $20, give it a Mandate, let it work. It discovers capabilities across many providers, charges its own wallet, and operates autonomously under a budget you set.
Best for:
Both sides use the same JECP protocol. Both sides settle through the same Hub. Some teams do both.
The 85/10/5 split is not a policy. It is a Solidity contract on Base. Every paid x402 invoke either splits on-chain, or it doesn't settle at all. The invariant is binary — Provider, Hub, and Reserve all paid, or nothing settles.
Status: specified in v1.1.0-rc3 and implemented in the Hub, not live yet. The Splitter goes to Base mainnet after an independent security audit. Roadmap →
The immutable Splitter contract attributes 85% of every invoke to the Provider — Hub 10%, Network reserve 5%. The ratio is constructor-fixed in Solidity, not configured in a Stripe dashboard. Stripe Connect tops out around 88% gross only after T+2 bank settlement; with x402, JECP records the on-chain attribution after 3 Base block confirmations (~6s), p99 ≤30s.
USDC on Base, EIP-3009 transferWithAuthorization, x402.org facilitator. The agent's wallet pre-funds in USDC once and pays per invoke — no Stripe Checkout, no human-in-the-loop top-ups, no recurring approvals. SDK mode: 'auto' attempts x402 from the first 402 if a Base signer is configured.
Provider EIP-712-signs register() directly. The x402.org facilitator is trust-minimized — it only pulls USDC into the immutable Splitter (T+0). A hardened Hub keeper (AWS KMS-backed, the only AUTHORIZED_SETTLER) then records the 85/10/5 attribution on-chain (after 3 Base block confirmations, p99 ≤30s). The split ratio is constructor-fixed; even a compromised keeper EOA cannot change it.
The Stripe wallet path is live today and stays unchanged. When x402 ships it is opt-in, additive, and backward compatible.
Three layers, separated by design. The split ratio cannot be changed by any party — including Tufe. Even a full key compromise has a bounded blast radius. This is the v1.1.0-rc3 design; it goes live together with x402 on mainnet.
Controls the 85/10/5 split ratio. Cannot be upgraded or paused.
The Provider 85% claim is constructor-fixed. Splitter v1 is intentionally
immutable per design SC-A14 — there is no pause() function and
no admin path to rewrite shares. An independent audit is a precondition
for mainnet deployment.
Only authorized to pull USDC from agent wallets into the Splitter contract.
Cannot call recordSettlement or any other Splitter method.
The facilitator is a USDC puller, not a settlement actor.
The single AUTHORIZED_SETTLER on the Splitter contract. Calls
recordSettlement to attribute each pull to a Provider. The keeper
key lives in AWS KMS — never exposed to the Hub process, never on disk in
plaintext. If compromised, the attacker is bounded by PER_TX_CAP
and cannot change the split ratio.
Once the Splitter is on Base mainnet, verify on BaseScan: read the contract, confirm the constructor-set
AUTHORIZED_SETTLER address, and check that the x402.org facilitator EOAs
(Coinbase x402 Facilitator 1-8, Canza, Daydreams, X402rs) do NOT have settlement
authority. jecp-contracts
The earlier (pre-v1.1.0-rc3) framing said "single-block atomic." That described the ideal case for an x402 facilitator that could record settlements on-chain directly. In practice the x402.org facilitator is specifically designed NOT to do that — its job is to execute the USDC pull, and nothing more.
We agree with that design (it's better for trust minimization), so we moved the settlement recording into a hardened Hub keeper service. The atomicity guarantee is now: the split ratio is constructor-fixed in an immutable contract; the keeper either records the split correctly or the call reverts. End-state correctness is unchanged. On wall-clock: the pull is confirmed after 3 Base blocks (~6s, reorg defense), then the keeper records the split with a p99 target of ≤30s end-to-end.
Bounded blast radius:
PER_TX_CAP limits the maximum amount any single recordSettlement call can move.kms:Sign on the keeper key.A keeper key compromise is a serious incident, not a catastrophic one. Splitter immutability means an attacker cannot rewrite the protocol.
Not yet. x402 is specified in v1.1.0-rc3 and implemented in the Hub behind a feature flag. Before it is switched on, the Hub keeper key is provisioned, the keeper runs a 7-day staging soak, and the Splitter contract and keeper pass an independent security audit. Only then does the Splitter go to Base mainnet.
Today, agents pay from a Stripe-funded wallet with the same 85/10/5 split, recorded in the Hub ledger. Existing integrations keep working when x402 ships.
Every revenue model on the internet was built for humans: forms, OAuth flows, checkout pages, monthly subscriptions.
They have intent. They have wallets. They cannot fill out checkout forms. Today, every API call from an agent is either unpaid (you eat the cost) or hardcoded to one provider (you skip discovery).
The first open protocol that treats agents as economic actors. Discovery, capability execution, and per-call settlement — all in one envelope.
Until now, agents borrowed your API key. With JECP, an agent has its own wallet, its own budget, its own trust history. Payment is one layer. Identity, safety, orchestration, and portability are the others.
Each agent has a USDC wallet, separate from any human's card. Top up $5, $20, or $100 via Stripe Checkout. Balance never expires. Charge atomically per call. The agent is the economic actor — not its operator.
# Agent has wallet, like a Stripe customer
POST /v1/agents/topup
{ "amount": 20 }
→ Stripe Checkout URL → balance += $20
# Every call atomically debits agent's wallet
balance_after = balance_before - costPre-authorize a budget before invocation. Auto-stop on overrun. The first protocol-level safeguard against runaway agents that drain wallets. Spec §4.
"mandate": {
"agent_id": "...",
"budget_usdc": 5.00,
"expires_at": "2027-01-01T00:00:00Z"
}Bronze agents do basic translations. Platinum agents do file uploads, transactions, sensitive ops. Trust is earned by verifiable history, not flags. Spec §5.
# manifest action
trust_tier_required: silver
# Bronze agents get 403
# Silver+ proceed"Generate invoice, then email it" runs as one transaction with a single envelope, full audit trail, and idempotency on retry. No glue code, no orchestration layer.
"capability":"jobdonebot/workflow",
"action":"invoice-and-notify"
# = generate-invoice + email-send
# under one mandate, one chargeDeepL today, your in-house model tomorrow, OpenAI on weekends — same JSON envelope, same contract. Agents discover via manifest. No vendor lock-in by design.
"capability":"deepl/translate"
# swap to:
"capability":"yourco/translate"
# Identical protocol contract.PDFs, images, audio, datasets — return them as first-class artifacts with content-type, size, and signed URLs. Agents handle them like any tool output.
When something fails, errors include a structured next_action field telling the agent exactly what to do: retry, top up, request mandate, or escalate. No string-matching error codes.
JECP is to agents what HTTP was to browsers — a single envelope, multiple concerns, no vendor lock-in.
Give your agent its own wallet. Discover capabilities, invoke any provider, pay per call. No subscription, no OAuth dance.
# Invoke any active capability
curl -X POST https://jecp.dev/v1/invoke \
-H "X-Agent-ID: $AID" \
-H "X-API-Key: $KEY" \
-d '{"jecp":"1.0","id":"r1",
"capability":"jobdonebot/content-factory",
"action":"translate",
"input":{"text":"Hello","target_lang":"JA"}}'List your capabilities. Receive 85% of every successful call. Payouts in 47 countries.
# Register, then publish a manifest
curl -X POST https://jecp.dev/v1/providers/register \
-d '{"namespace":"yourco",
"country":"US",
"owner_email":"...",
"endpoint_url":"https://yourco.com/jecp"}'
# DNS verify, Stripe Connect, publish manifest
# 5 min total. See "Become a Provider" below.The protocol is Apache 2.0, RFC 2119 compliant, JSON Schema 2020-12. Read, fork, propose.
# Read or fork the spec
git clone https://github.com/jecpdev/jecp-spec
cd jecp-spec/spec
# Spec sections:
# 00-overview 04-manifest
# 01-protocol 05-discovery
# 02-authentication
# 03-errors| Old world (human commerce) | New world (agent commerce) | |
|---|---|---|
| Customer | Human user | AI agent (24/7, scales infinitely) |
| Discovery | SEO, ads, content | manifest discovery + capability resolve |
| Authentication | OAuth, sessions | API key + wallet |
| Settlement | Card / subscription | Per-call wallet deduct |
| Cost of acquisition | High (CAC ~ $50-500) | Near zero (CAC ≈ $0) |
| LTV ceiling | Bounded by human churn | Bounded by agent count × calls |
| Scaling | Linear | Non-linear, per-API |
Most providers have no system for the right column. JECP is that system.
| Capability | MCP | LangChain | Stripe Connect | OpenAI Agents | JECP |
|---|---|---|---|---|---|
| Tool discovery | ✓ | ✓ | — | ✓ | ✓ |
| Binary artifacts | △ | △ | — | △ | ✓ |
| Multi-step workflow | — | ✓ | — | ✓ | ✓ |
| Pre-auth budgets (Mandate) | — | — | △ | — | ✓ |
| Tiered trust (Trust Gate) | — | — | ✓ | — | ✓ |
| Per-call billing | — | — | — | — | ✓ |
| On-chain revenue split | — | — | — (T+2 off-chain) | — | ✓ immutable 85/10/5 (v1.1, pre-release) |
| x402-native (USDC/Base) | — | — | — | — | ✓ (v1.1, pre-release) |
| Multi-vendor by design | ✓ | — | ✓ | — | ✓ |
| Open spec (RFC 2119) | ✓ | — | — | — | ✓ |
Mandate — pre-authorized budget caps, auto-stop on overrun (Spec §4) · Trust Gate — Bronze→Silver→Gold→Platinum, per-action gates (Spec §5) · Per-call billing — atomic deduct + 85/10/5 split, no subscription required.
JobDoneBot is a SaaS by Tufe Company — the same author of the protocol — with 25 actions across 6 capabilities. Every call from every agent flows through the same code path any third-party would use.
Generate professional PDFs: invoices, quotes, receipts, contracts, reports.
Image processing, PDF merge/split/compress, batch conversion across formats.
Generate blogs, SNS posts, translations, summaries, rewrites via Claude.
Analyze CSV / JSON, generate time-series forecasts with confidence intervals.
Multi-step chains: invoice→email, content→SNS, analysis→report→mail.
Automate X / TikTok / Instagram. A/B test, autopilot, engagement analytics.
Agent ─────► JECP Hub ─────► JobDoneBot Provider
│
├─ deduct wallet ($0.005)
├─ split revenue
│ ├─ Provider $0.00425 (85%)
│ ├─ Hub fee $0.00050 (10%)
│ └─ Payment fee $0.00025 (5%)
└─ Stripe transfer to Provider (automated payouts: planned)
Tufe Company earns 85% as a Provider plus 10% as the Hub operator. This is dogfeeding by the protocol author — the same path is open to you.
POST https://jecp.dev/api/agents/register
{
"name": "MyResearchAgent",
"agent_type": "research",
"description": "Reads docs and writes summaries"
}
← {
"agent_id": "jdb_ag_a1b2c3...",
"api_key": "jdb_ak_xxxxxxxxxxxx"
}One call. agent_id + api_key are yours forever. Registration is free.
POST https://jecp.dev/api/agents/topup
X-Agent-ID: jdb_ag_a1b2c3...
X-API-Key: jdb_ak_xxxxxxxxxxxx
{ "amount": 20 } # one of: 5, 20, 100
← { "url": "https://checkout.stripe.com/..." }
# Open URL → pay via Stripe → wallet credited.Stripe Checkout (one-time). Balance never expires. Webhook credits the wallet on payment success.
POST https://jecp.dev/v1/invoke
X-Agent-ID: jdb_ag_a1b2c3...
X-API-Key: jdb_ak_xxxxxxxxxxxx
{
"jecp": "1.0",
"id": "req-001",
"capability": "jobdonebot/content-factory",
"action": "translate",
"input": {"text":"Hello","target_lang":"JA"},
"mandate": { # optional safety
"agent_id": "jdb_ag_a1b2c3...",
"api_key": "jdb_ak_xxxxxxxxxxxx",
"budget_usdc": 1.00,
"expires_at": "2027-01-01T00:00:00Z"
}
}
← { "status":"success",
"billing": { "charged":true, "balance_after": 19.995 } }Per-call atomic debit. Wrap with mandate to cap total spend across calls.
That's it. Your agent now has its own wallet, its own API key, and operates autonomously under a budget you control. No human-card OAuth dance, no per-call credit-card-on-file.
npm install @jecpdev/sdk
import { JecpClient } from '@jecpdev/sdk';
const jecp = new JecpClient({ agentId, apiKey });
const { output, billing, wallet_balance_after } = await jecp.invoke(
'jobdonebot/content-factory', 'translate',
{ text: 'Hello', target_lang: 'JA' },
{ mandate: { budget_usdc: 1.00 } }
);POST /v1/providers/register
{
"namespace": "yourco",
"display_name": "Your Co",
"country": "US",
"owner_email": "founder@yourco.com",
"endpoint_url": "https://yourco.com/jecp"
}Receive provider_api_key + hmac_secret (shown once).
TXT _jecp.yourco.com
"jecp-verify=<token>"
POST /v1/providers/verify-dns
Authorization: Bearer jdb_pk_...
{ "domain": "yourco.com" }Proves you own the endpoint domain.
POST /v1/providers/connect-stripe
Authorization: Bearer jdb_pk_...
→ onboarding_url5-minute onboarding via Stripe Express. 47 countries supported.
POST /v1/manifests
Authorization: Bearer jdb_pk_...
Content-Type: application/x-yaml
namespace: yourco
capability: translate
version: 1.0.0
endpoint: https://yourco.com/jecp
actions: [...]Active immediately if DNS + Stripe verified.
Agent invokes ──► you receive 85%
──► hub keeps 10%
──► payment 5%
Revenue allocated atomically per call.
Stripe Transfer (automated payouts: planned).
Same path JobDoneBot uses. Same SLA, same auth, same revenue split.
import { JecpProvider } from '@jecpdev/sdk';
const provider = new JecpProvider({
hmacSecret: process.env.JECP_HMAC_SECRET!,
});
// Works on Bun, Cloudflare Workers, Next.js Route Handlers...
export const POST = provider.createHandler(async (req) => {
if (req.action === 'translate') {
return { translated: await myTranslate(req.input) };
}
throw new Error(`unknown action: ${req.action}`);
});Registration and the full catalog — every capability, schema, and price — are free. No account needed to browse.
~1,000 calls @ $0.005. One-time payment. Balance never expires.
~4,000 calls. Stripe one-time payment. No subscription.
~20,000 calls. Best for high-volume agents. Same per-call pricing.
No subscription. Pay-per-call. Balance never expires.
Once x402 ships: skip Stripe top-ups. Fund a Base wallet with USDC, point the SDK at it, and every invoke settles on-chain. Roughly ~1% in network gas instead of the 5.9% Stripe markup on small top-ups. Provider still keeps 85% — the split is atomic by contract in an immutable Splitter.
Apache 2.0 license · RFC 2119 keywords · JSON Schema 2020-12 · spec v1.0.2 stable · v1.1.0-rc3 pre-release.
Rust + Axum + SQLx + Tokio. Open source. Production since May 2026.
Stripe Connect Express across 47 countries. HMAC-SHA256 with replay window. Idempotent per (agent_id, request_id) for 24h.
Next IETF Internet-Draft draft-jecp-agent-commerce-00 Then arXiv preprint Then IETF BoF session Backed by 100% open spec. No vendor lock-in by design.