The first agent-commerce protocol with atomic on-chain 85/10/5 revenue split (~3s typical on Base). x402-native. Provider keeps 85% on every invoke. No top-ups, no wait, no middlemen.
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 invoke either splits on-chain (typically within ~3s on Base), or it doesn't settle at all. The invariant is binary — Provider, Hub, and Reserve all paid, or nothing settles.
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; JECP records the on-chain attribution typically within ~3 seconds (≤2 blocks, 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 (T+~3s, ≤2 blocks, p99 ≤30s). The split ratio is constructor-fixed; even a compromised keeper EOA cannot change it.
Stripe wallet path stays operational and unchanged. x402 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.
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.
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.
Verify on BaseScan: read the Splitter 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. Wall-clock latency is ~3 seconds typical, ≤30 seconds at p99 worst-case.
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.
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": "2026-06-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":"deepl/translate",
"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 (Hub keeper-recorded, ~3s) |
| x402-native (USDC/Base) | — | — | — | — | ✓ |
| 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: Q3 2026)
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",
"free_calls_remaining": 100
}One call. agent_id + api_key are yours forever. 100 free calls included.
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": "deepl/translate",
"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": "2026-06-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: Q3 2026).
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}`);
});100 calls per registered agent. Try every capability. No credit card required.
~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.
Skip Stripe top-ups entirely. 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% — recorded by the Hub keeper into an immutable Splitter, typically within ~3 seconds.
Apache 2.0 license · RFC 2119 keywords · JSON Schema 2020-12 · spec v1.1.0-rc3 (rc3 supersedes rc2).
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.
Q3 2026 IETF Internet-Draft draft-jecp-agent-commerce-00 Q4 2026 arXiv preprint Q1 2027 BoF session at IETF 122 Backed by 100% open spec. No vendor lock-in by design.