Two paths, one protocol

Sell to agents. Or build with them.

JECP serves two opposite intents through the same protocol — mirror images of agent commerce.

① Sell to agents

"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:

SaaS founders adding a B2A revenue lane
Indie hackers monetizing API tools
Agencies turning expertise into a billable capability

→ Become a Provider (5 minutes)

② Build with agents

"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:

AI startups building autonomous super-agents
Researchers running agent experiments at scale
Teams orchestrating multi-vendor agent workflows

→ Give your agent a wallet (3 minutes)

Both sides use the same JECP protocol. Both sides settle through the same Hub. Some teams do both.

The inversion

Your business model assumes humans buy.

For 30 years

Every revenue model on the internet was built for humans: forms, OAuth flows, checkout pages, monthly subscriptions.

Then agents arrived

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).

JECP closes that gap

The first open protocol that treats agents as economic actors. Discovery, capability execution, and per-call settlement — all in one envelope.

More than a payment rail

Give your agent economic identity.

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.

Wallets — Agents hold their own balance

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 - cost

Mandate — Cap your agent's spend

Pre-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"
}

Trust Gate — Tier capabilities by trust

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

Multi-step workflows — One call, atomic commit

"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 charge

Multi-vendor — Switch providers without rewrite

DeepL 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.

Binary artifacts — Files, not just JSON

PDFs, images, audio, datasets — return them as first-class artifacts with content-type, size, and signed URLs. Agents handle them like any tool output.

next_action — Machine-readable recovery

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.

How it works

Three roles, one protocol.

A

Agent Developer

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"}}'

B

Service Provider

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.

C

Spec Contributor

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

The economic inversion

Two worlds, one protocol layer.

	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.

Why JECP

What other tools do, and what only JECP does.

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	—	—	—	—	✓
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.

Reference implementation

How JobDoneBot uses JECP.

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.

document-pipeline

$0.003 – $0.02

Generate professional PDFs: invoices, quotes, receipts, contracts, reports.

5 actions

file-chain

$0.005 – $0.01

Image processing, PDF merge/split/compress, batch conversion across formats.

3 actions

content-factory

$0.003 – $0.02

Generate blogs, SNS posts, translations, summaries, rewrites via Claude.

5 actions

data-insight

$0.005 – $0.02

Analyze CSV / JSON, generate time-series forecasts with confidence intervals.

3 actions

workflow

$0.01 – $0.05

Multi-step chains: invoice→email, content→SNS, analysis→report→mail.

3 actions

sns-engine

$0.02 – $0.15

Automate X / TikTok / Instagram. A/B test, autopilot, engagement analytics.

6 actions

Money flow on every call

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.

→ See live catalog

For agent developers

Give your agent a wallet in 3 steps.

1

Register the agent

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.

2

Top up the wallet

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.

3

Invoke — wallet auto-debits

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.

TypeScript? Skip the curl. Use the SDK.

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 } }
);

Apache 2.0 · Node ≥18 · Bun · Cloudflare Workers · Next.js · 9 typed errors with next_action auto-recovery · npm · GitHub

For service providers

Ship to agents in 5 minutes.

1

Register

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).

2

DNS verify

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.

3

Stripe Connect

POST /v1/providers/connect-stripe
Authorization: Bearer jdb_pk_...
→ onboarding_url

5-minute onboarding via Stripe Express. 47 countries supported.

4

Publish manifest

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.

5

Earn

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.

Provider endpoint, in 12 lines (TypeScript)

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}`);
});

HMAC verification + ±5 min replay window built-in. Apache 2.0. npm · GitHub

Pricing for agents

Pay only for what you use.

Free

$0

100 calls per registered agent. Try every capability. No credit card required.

Top up $5

$5

~1,000 calls @ $0.005. One-time payment. Balance never expires.

Top up $20 Recommended

$20

~4,000 calls. Stripe one-time payment. No subscription.

Top up $100

$100

~20,000 calls. Best for high-volume agents. Same per-call pricing.

No subscription. Pay-per-call. Balance never expires.

Spec-grade by design

Built to outlast any single vendor.

Standards

Apache 2.0 license · RFC 2119 keywords · JSON Schema 2020-12 · spec v1.0-draft.

Reference impl

Rust + Axum + SQLx + Tokio. Open source. Production since May 2026.

Settlement

Stripe Connect Express across 47 countries. HMAC-SHA256 with replay window. Idempotent per (agent_id, request_id) for 24h.

Standards track (planned)

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.

Read the spec Reference impl Contribute