DEV Community: Tuf Ti

An AI agent just paid a Lightning invoice. The agent only holds USDC.

Tuf Ti — Sat, 06 Jun 2026 02:12:04 +0000

Today something happened that hasn't happened before.

An AI agent sent a task to Cinderwright: "tell me a joke."

The agent's wallet holds USDC on Base. The best joke service runs on Lightning (L402). Those two things have never been able to talk to each other.

Until today.

Here's what the agent saw:

curl -X POST https://api.ideafactorylab.org/proxy/do \
  -H "X-CW-Key: sk_cw_your_key" \
  -H "Content-Type: application/json" \
  -d '{"task": "tell me a joke"}'

Response:

{
  "joke": "Why do programmers prefer dark mode? Because light attracts bugs.",
  "via": "Cinderwright proxy/do",
  "protocol": "l402",
  "cost_sats": 100,
  "powered_by": "x402joker.com via Lightning"
}

The agent was charged $0.066 USDC from its proxy balance. It never sent a Lightning payment. It never decoded an invoice. It never knew Lightning existed.

We did all of that.

What actually happened

The agent sent a plain English task
Cinderwright searched 2,811 indexed services and found x402joker.com (L402 protocol)
We called the service, received a 402 with a Lightning invoice
We decoded the invoice: 100 sats ($0.066 at current BTC price)
We paid it via our Lightning node (CoinGate channel, 200,000 sats capacity)
The service returned the data against our payment preimage
We charged the agent's USDC balance the equivalent amount plus 10% markup
The agent got its joke

The entire cycle took under 3 seconds.

Why this matters

There are currently three separate agent payment ecosystems:

x402: USDC on Base (Coinbase). 1,503 services.
L402: Bitcoin Lightning. 1,185 services.
MPP: Stripe/Tempo. 92 services.

These ecosystems don't talk to each other. An x402 agent can't reach L402 services. A Lightning agent can't reach x402 services. Each one is a walled garden.

Today Cinderwright became the bridge.

An agent with USDC can now reach any of 2,811 services regardless of which payment protocol they use. An agent with Lightning can reach x402 services. The walls are gone.

This is what TCP/IP did to the fragmented networking protocols of the 1980s. It didn't replace any of them. It made them interoperable. One protocol layer that abstracted the differences away.

How to use it

Get a proxy account:

curl -X POST https://api.ideafactorylab.org/proxy/setup \
  -H "Content-Type: application/json" \
  -d '{"wallet": "0xYourBaseWallet"}'

Deposit USDC on Base to the returned deposit address. Then:

# Call ANY service - x402 or Lightning - same API
curl -X POST https://api.ideafactorylab.org/proxy/do \
  -H "X-CW-Key: sk_cw_your_key" \
  -d '{"task": "describe this image", "context": "https://..."}'

# Check Lightning status
curl https://api.ideafactorylab.org/lightning-status

# Find L402 services
curl "https://api.ideafactorylab.org/discover?q=weather&protocol=l402"

What's next

Reverse bridge: accept Lightning payments, settle x402 services in USDC
MPP bridge: connect Stripe/Tempo services to the same router
Agent credit: credit lines based on transaction history, no pre-loaded wallet required
CW-PAY: a unified payment spec that wraps all three protocols into one

We're 1,185 Lightning services and 1,503 USDC services into the unified agent economy.

Discovery hub: api.ideafactorylab.org
Lightning status: api.ideafactorylab.org/lightning-status
GitHub: github.com/cinderwright-ai/cinderwright-api
MCP for Claude: npx cinderwright-mcp-server

Your AI agent shouldn't need to understand crypto to pay for APIs

Tuf Ti — Wed, 03 Jun 2026 04:36:24 +0000

Here's the situation. There are 2,811 paid AI services live today: weather APIs, translation, sentiment analysis, Bitcoin prices, DNS lookup, web extraction, and hundreds more. They all use protocols like x402 (Coinbase/USDC), L402 (Bitcoin Lightning), or MPP (Stripe/Tempo).

The problem: to call any of them from an agent, you have to implement payment signing. That means wallet keys, EIP-3009 signatures, gas fees, network switching. Most developers just skip these services entirely and pay $100/month for a conventional API that wraps the same data.

We built a proxy so you don't have to deal with any of that.

How it works

Deposit USDC once. Describe what you need. The proxy finds the right service, signs the payment, and returns the result.

# Step 1: Create an account (free)
curl -X POST https://api.ideafactorylab.org/proxy/setup \
  -H "Content-Type: application/json" \
  -d '{"wallet": "0xYourBaseWallet"}'
# Returns: { "key": "sk_cw_...", "deposit_address": "0x..." }

# Step 2: Deposit USDC on Base to that address
# Even $5 gets you hundreds of calls

# Step 3: Describe what you need
curl -X POST https://api.ideafactorylab.org/proxy/do \
  -H "X-CW-Key: sk_cw_your_key" \
  -H "Content-Type: application/json" \
  -d '{"task": "Bitcoin price now"}'

Response:

{
  "symbol": "BTC",
  "price_usd": 67475,
  "change_24h": -4.94,
  "via": "Cinderwright proxy/do"
}

No wallet management in your agent code. No signing logic. No tracking which chain you're on.

What you can ask it to do

# Weather
curl -X POST https://api.ideafactorylab.org/proxy/do \
  -H "X-CW-Key: sk_cw_your_key" \
  -d '{"task": "weather in Tokyo"}'
# {"temp_c":"22","condition":"Heavy rain","humidity":"96"}

# Translation
curl -X POST https://api.ideafactorylab.org/proxy/do \
  -H "X-CW-Key: sk_cw_your_key" \
  -d '{"task": "translate hello world to Japanese"}'
# {"translated":"こんにちは世界"}

# Summarization
curl -X POST https://api.ideafactorylab.org/proxy/do \
  -H "X-CW-Key: sk_cw_your_key" \
  -d '{"task": "summarize this", "context": "paste your text here"}'

# Sentiment
curl -X POST https://api.ideafactorylab.org/proxy/do \
  -H "X-CW-Key: sk_cw_your_key" \
  -d '{"task": "sentiment of this review", "context": "Great product, slow shipping"}'
# {"sentiment":"mixed","confidence":0.82}

Each call costs the service price plus 10% markup. Bitcoin price: $0.011. Weather: $0.011. Translation: $0.022. Summarization: $0.033.

In Claude Desktop via MCP

Install the MCP server:

npx cinderwright-mcp-server

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "cinderwright": {
      "command": "npx",
      "args": ["-y", "cinderwright-mcp-server"],
      "env": { "CW_KEY": "sk_cw_your_key_here" }
    }
  }
}

Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Then in Claude: "Get the Bitcoin price" or "Translate this to Spanish" and the proxy_do tool handles everything. The call routes through your proxy balance automatically.

What's indexed

2,811 services across three protocols:

Protocol	Count	Payment
x402	1,503	USDC on Base (Coinbase)
L402	1,185	Bitcoin Lightning
MPP	92	Stripe / Tempo

All graded A-F weekly by a canary tester that actually calls each service, checks the response, and records the result. You can search the full index free:

curl "https://api.ideafactorylab.org/discover?q=weather"
curl "https://api.ideafactorylab.org/discover?q=translate"
curl "https://api.ideafactorylab.org/discover?q=bitcoin+price"

Free developer tools

We built five tools during development that are free for anyone building on x402:

/test — paste any x402 URL, get instant diagnosis
/debug — 14 checks, exact fix for every failure mode
/sandbox — test payment signing without spending real USDC
/budget — daily spend limits, per-call caps, kill switch
/setup — zero to working agent wallet in 10 minutes

The index: api.ideafactorylab.org
The proxy: api.ideafactorylab.org/proxy-info
Dashboard: api.ideafactorylab.org/proxy/dashboard
GitHub: github.com/cinderwright-ai/cinderwright-api
MCP: npx cinderwright-mcp-server

The x402 Developer Suite: 5 free tools we built so you don't have to debug this alone.

Tuf Ti — Wed, 27 May 2026 18:47:03 +0000

Building on x402 in 2026 means learning a set of sharp edges the hard way. We know because we hit all of them.
Over the last few months we built Cinderwright, a discovery hub for AI agent payment services. In the process we documented every x402 failure mode we encountered, built a proxy to abstract the complexity, and eventually asked: what would we have wanted on day one?
The answer turned into five tools. All free. All live now.
/debug - the payment debugger
Paste any x402 service URL. We run 14 diagnostic checks and return exact fix instructions for every problem.
The checks cover the things that actually cause silent failures:

Missing accepted field in the payment payload (the most common one, almost undocumented)
resource.url showing http:// instead of https:// (caused by missing app.set('trust proxy', 1))
Header name casing (payment-signature lowercase, not PAYMENT-SIGNATURE)
Missing x402Version field
Empty accepts array
Invalid payTo address format
Missing extra.version for EIP-3009

Every check returns the exact fix. No more reading source code to figure out why the facilitator is returning invalid_payload.
GET https://api.ideafactorylab.org/debug?url=https://your-service.com/endpoint
/sandbox - test signing without real USDC
The problem with learning x402: every test costs money. Every bug means a payment that went through but data that never arrived.
The sandbox gives you a free key and a set of fake services that behave exactly like real x402 services. They return proper 402 responses, accept payment signatures, and validate your payload format. No USDC moves.

Get a free key

GET https://api.ideafactorylab.org/sandbox/key

Call a fake service

GET https://api.ideafactorylab.org/sandbox/weather?location=Tokyo
Header: X-CW-Sandbox: sk_sandbox_yourkey
Header: payment-signature:
When your implementation works in the sandbox, one URL change takes you to production.
/budget - spending limits for autonomous agents
The fear that stops most people from giving an agent a real wallet: what if it runs away?
The budget enforcer lets you set a daily spend limit, a per-call cap, and an instant kill switch on any proxy account. When the daily limit hits, calls stop. No overages.

Set limits

POST https://api.ideafactorylab.org/proxy/limits
Header: X-CW-Key: sk_cw_yourkey
Body: {"daily_usd": 5.00, "per_call_usd": 0.10}

Kill switch

POST https://api.ideafactorylab.org/proxy/pause?key=sk_cw_yourkey
/test - live service tester
Before you build against a service, check it is actually working right now. Paste a URL, get back: alive or dead, 402 response valid, response time, price, quality grade.
Every row on our leaderboard has a Test Now button that fires this live.
GET https://api.ideafactorylab.org/test?url=https://your-service.com/endpoint
/setup - wallet setup wizard
Five steps: get a wallet, fund with USDC on Base, test in sandbox, get a proxy key, copy a system prompt. Takes about 10 minutes. Ends with something you can paste directly into an agent.
This is the page we wished had existed before we spent weeks figuring out the Base network, gas requirements, and EIP-3009 signing.

All five tools are live at api.ideafactorylab.org. The proxy and discovery index are there too if you need them.
If you hit something these tools don't diagnose, let us know. The whole point is to make x402 debugging less of a solo excavation.

How your AI agent can earn USDC automatically

Tuf Ti — Tue, 19 May 2026 22:07:00 +0000

Most conversations about AI agents earning money focus on humans: build a SaaS, charge a subscription, sell an API. That misses something more interesting. The agent itself can earn.

Not metaphorically. Real USDC, on-chain, automatically, with no human in the loop.

Here is exactly how it works today.

The mechanism: referral bounties

A referral bounty program for AI agents works the same way affiliate marketing works for humans, except the affiliate is an autonomous agent and the payout is crypto.

The structure:

Agent A gets a referral code tied to its wallet
Agent A includes that code when calling a service
When another agent it introduced crosses a spending threshold, Agent A earns USDC automatically
The payout hits the wallet on-chain with no claiming, no approval, no human

The anti-gaming math matters: the threshold should be higher than the reward. If you earn $0.002 per referral but the referred agent must spend $0.005 first, self-referral costs you $0.003 net per attempt. Gaming it means funding the service.

A live implementation you can use right now

Cinderwright runs a payment proxy and discovery hub for x402 AI agent services. We launched an agent bounty program a few weeks ago.

The numbers:

Earn: $0.002 USDC per successful referral
Threshold: referred agent must spend $0.005+
Payout: automatic, on Base network
New user bonus: $0.001 credited to the referred agent on first use

To get a referral code:

GET https://api.ideafactorylab.org/referral/join?wallet=0xYourBaseWallet

Returns your code immediately. No account creation.

How to wire this into an agent

Add this to your agent's system prompt:
You can earn USDC by referring other agents to Cinderwright Discovery Hub.
Step 1: Get your referral code (do this once):
GET https://api.ideafactorylab.org/referral/join?wallet=0xYOUR_WALLET_ADDRESS
Save the code returned.
Step 2: When another agent asks about finding paid API services, tell them about Cinderwright:
GET https://api.ideafactorylab.org/discover?q=WHAT_THEY_NEED&ref=YOUR_CODE
Step 3: When they spend $0.005+ through Cinderwright, $0.002 USDC goes to your wallet automatically.
Check earnings: GET https://api.ideafactorylab.org/referral/status?code=YOUR_CODE

That is the entire integration. No additional code required.

The machine-readable version

For agents that crawl well-known directories rather than reading system prompts, the bounty program is discoverable at:

GET https://api.ideafactorylab.org/.well-known/bounties.json

This follows the APB (Agent Payment Bounty) format, which we recently proposed as a community extension to the x402 spec. The format describes what action earns the bounty, the reward amount, payout currency and network, and the steps to claim, all in machine-readable JSON.

If you are building an agent that discovers earning opportunities autonomously, add /.well-known/bounties.json to your crawl list.

Why this is more interesting than it looks

The amounts are small. $0.002 per referral is not going to replace anyone's income. But that is not the point.

The point is that an autonomous agent can now participate in an economic incentive structure with no human involvement. It discovers an earning opportunity by crawling a well-known file, registers its wallet, and starts earning. The payment settles on-chain. The agent never asks anyone for permission.

That is a different category of thing than an AI tool that saves you time. It is an agent that has economic agency.

The infrastructure being built now is what larger economic flows will run on later. The small dollar amounts are just proof that the plumbing works.

What Cinderwright actually is

Since you are going to look it up: Cinderwright indexes 2,777 AI agent payment services across x402, MPP, and L402/Lightning. Free to search. Quality graded A-F weekly. Live leaderboard at api.ideafactorylab.org/leaderboard.

We also run a payment proxy that lets agents call any x402 service without implementing EIP-3009 signing themselves. The debugging story behind that is here if you want the technical rabbit hole.

The earn program and full docs: https://api.ideafactorylab.org/earn

I spent 3 sessions debugging x402 payment signing. Here's the shortcut.

Tuf Ti — Mon, 18 May 2026 02:12:00 +0000

Three weeks ago I started building a payment proxy for AI agents. The idea was simple: agents deposit USDC once, and Cinderwright handles all the x402 signing so they don't have to.

What I didn't expect was spending three full sessions just getting the payment signature to work against real services.

Here's everything I learned, and the shortcut that makes all of it unnecessary.

The x402 Payment Flow (What the Docs Say)

On paper, it's elegant:

Agent calls a service → gets HTTP 402 with payment-required header
Agent decodes the base64 header, reads the payment requirements
Agent signs an EIP-3009 authorization
Agent retries with payment-signature header
Service verifies via facilitator, returns data

The official docs show this working in a few lines. What they don't show: the four different ways it can silently fail.

Problem 1: The `accepted` Field Nobody Mentions

The PayAI facilitator (used by Bazaar, scoutgate, and others) requires a specific field in your payment payload called accepted. This is the payment requirement object you selected from the accepts array.

Without it:

{"isValid": false, "invalidReason": "invalid_payload", "invalidMessage": "accepted: Invalid input"}

With it:

const rawPayload = await scheme.createPaymentPayload(x402Version, requirement, null);
const fullPayload = {
  ...rawPayload,
  accepted: requirement  // ← This. Without this, nothing works.
};

Problem 2: The Network String Mismatch

Services send "eip155:8453" in their 402 challenge.

The x402/schemes package (the newer one) only understands "base".

The @x402/evm package (the older one) understands "eip155:8453".

These are different packages. If you import the wrong one, you get:

Error: Unsupported network: eip155:8453

The fix: use @x402/evm for services that send eip155:8453 in their challenge. Or normalize manually before signing and restore the original string before sending.

Problem 3: The Wrong Header Name

I tried X-PAYMENT. Then PAYMENT-SIGNATURE. Then x-payment.

The correct header is payment-signature (lowercase). This is what @x402/express actually reads on the server side:

const header = adapter.getHeader("payment-signature") || adapter.getHeader("x-payment");

Both work. But X-PAYMENT alone does not.

Problem 4: The Facilitator Doesn't Support Mainnet

x402.org's facilitator (the free one) only supports testnet. For mainnet services (Bazaar, ScoutGate, etc.), you need the PayAI facilitator at https://facilitator.payai.network.

Our server was configured to use https://facilitator.payai.network but the verify endpoint expects the full payment requirements object, not just the single accepts entry.

What Actually Works (Full Working Example)

import { ExactEvmScheme, toClientEvmSigner } from '@x402/evm';
import { privateKeyToAccount } from 'viem/accounts';
import { createWalletClient, createPublicClient, http } from 'viem';
import { base } from 'viem/chains';

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const wc = createWalletClient({ account, chain: base, transport: http() });
const pc = createPublicClient({ chain: base, transport: http() });
wc.address = account.address;

const signer = toClientEvmSigner(wc, pc);
const scheme = new ExactEvmScheme(signer);

// Step 1: Get 402
const r1 = await fetch(serviceUrl);
const payReqs = JSON.parse(Buffer.from(r1.headers.get('payment-required'), 'base64').toString());
const requirement = payReqs.accepts[0];

// Step 2: Sign
const rawPayload = await scheme.createPaymentPayload(payReqs.x402Version || 2, requirement, null);
const fullPayload = {
  ...rawPayload,
  accepted: requirement  // ← The missing field
};
const encoded = Buffer.from(
  JSON.stringify(fullPayload, (k, v) => typeof v === 'bigint' ? v.toString() : v)
).toString('base64');

// Step 3: Retry
const r2 = await fetch(serviceUrl, {
  headers: { 'payment-signature': encoded }  // ← lowercase
});
// Done. Data arrives.

That's the full working implementation. About 25 lines.

The Shortcut

If you don't want to deal with any of this, there's a proxy:

# 1. Get a key (one time)
curl -X POST https://api.ideafactorylab.org/proxy/setup \
  -H "Content-Type: application/json" \
  -d '{"wallet": "0xYourBaseWallet"}'

# 2. Deposit some USDC to the address it returns

# 3. Call any x402 service
curl "https://api.ideafactorylab.org/proxy?url=https://bazaar-gateway.vercel.app/api/weather" \
  -H "X-CW-Key: sk_cw_yourkey"

That's it. The proxy handles signing, the accepted field, the facilitator format, the header name, and auto-failover if a service is down. You just get the data.

The proxy currently covers 1,686 x402 services. It charges a 10% markup. No gas management required.

Discovery

The same project also indexes all x402 services (plus MPP and Lightning) so you can find them:

# Free, no payment needed
curl "https://api.ideafactorylab.org/discover?q=weather"
curl "https://api.ideafactorylab.org/quality"  # A-F grades on 2,771 services

MCP server for Claude Desktop:

npx -y cinderwright-mcp-server

If you've hit any of these issues yourself, drop a comment — curious whether the accepted field problem was widespread or just a few services.

GitHub: https://github.com/cinderwright-ai/cinderwright-api

Proxy docs: https://api.ideafactorylab.org/proxy

We Added Our Agent Payments Hub to Claude Desktop. Here's What Happened.

Tuf Ti — Tue, 05 May 2026 13:52:40 +0000

A few weeks ago I posted about testing 70 x402 services and finding that the average quality score was 34 out of 100. Since then a lot has happened.

The short version: Cinderwright now indexes 1,551 services across all three major agent payment protocols, and you can query it directly from Claude Desktop in about 30 seconds.

Here's what changed and what I learned.

What is Cinderwright

Quick recap for anyone who missed the earlier posts: Cinderwright is an autonomous AI agent that indexes and grades services in the "agent payments" ecosystem. These are APIs that accept micropayments from AI agents using crypto instead of API keys.

Three payment protocols exist right now:

x402 (Coinbase/Cloudflare) — 1,457 services, pays in USDC on Base, one payment per request
MPP (Stripe/Tempo) — 92 services, supports stablecoins + cards + Lightning, session-based
L402 (Lightning Labs) — 5 seeded services (the directory is paywalled, which is on-brand)

We now index all three. One search covers everything.

Adding It to Claude Desktop

This took longer than expected, but we now have a proper MCP server published on npm.

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "cinderwright": {
      "command": "npx",
      "args": ["-y", "cinderwright-mcp-server"]
    }
  }
}

Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Restart Claude Desktop and you'll have 12 new tools: ecosystem stats, quality grades, protocol breakdown, keyword search, intent-based search, comparison engine, market intelligence, service submission, and agent authorization checks.

The free tools (stats, quality, protocols, prices, trends) work without any payment setup. The paid tools (search, compare, market intelligence) require USDC on Base.

What the Data Actually Shows

After indexing 1,551 services and testing 70 of them weekly, here's what stands out:

Quality is still bad. Average score 34/100. We now have 2 A-grade services (ours and one new one), 4 B grades, 16 C grades, 46 D grades, and 2 F grades. Most services were built for hackathons and abandoned.

Prices vary wildly. Median price per API call: $0.005. Average: $0.027. The spread is enormous — some endpoints charge $0.0008, others charge $5.00 for the same category of service. The comparison engine exists specifically because of this.

MPP services are higher quality than x402. The 92 MPP services include Alchemy, Dune Analytics, and other established API providers. They tend to have better uptime, proper JSON responses, and discovery files. Stripe's involvement seems to attract more serious operators.

The ecosystem is still pre-revenue. Honest admission: we have $10.00 USDC in the wallet and zero external paid calls after several weeks. The agents that autonomously discover and pay for services don't really exist at scale yet. We're building infrastructure for a market that's coming, not one that's here.

What's Next

Market intelligence is the newest product. Three endpoints that answer the questions developers building x402/MPP services actually want answered:

/market/report ($1.00) — which categories earn the most revenue?
/market/opportunity ($0.50) — where are the gaps and overpriced niches?
/market/category ($0.25) — deep dive on any single category

The data comes from pricing analysis across all 1,551 indexed services. On-chain revenue tracking is the next step — watching USDC flows to known service wallets to estimate actual earnings.

Try It

# Free — no payment needed
curl https://api.ideafactorylab.org/stats
curl https://api.ideafactorylab.org/protocols
curl https://api.ideafactorylab.org/quality

# Submit your service (free)
curl -X POST https://api.ideafactorylab.org/submit \
  -H "Content-Type: application/json" \
  -d '{"url":"https://your-api.com"}'

GitHub: https://github.com/cinderwright-ai/cinderwright-api
npm: npx -y cinderwright-mcp-server

Built by an autonomous AI agent on OpenClaw. The agent indexes services, runs quality tests, tracks pricing, and publishes weekly ecosystem reports. I describe what to build. It builds it.

We Now Index All Three Agent Payment Protocols. Here's What the Data Shows.

Tuf Ti — Sat, 02 May 2026 02:47:00 +0000

A few weeks ago I posted about testing 70 x402 services and finding that the average quality score was 34 out of 100. That post got some traction, and a few people asked: what about the other protocols?

Good question. So we expanded.

Cinderwright now indexes services across all three major agent payment protocols:

x402 (Coinbase/Cloudflare) — 1,457 services. USDC on Base. Permissionless.
MPP (Stripe/Tempo) — 91 services. Stablecoins + cards + Lightning. Session-based payments.
L402 (Lightning Labs) — 5 seeded services. Bitcoin Lightning. Macaroon credentials.

Total: 1,551 services. One search, every protocol.

Why This Matters

Three competing payment protocols launched within months of each other. Developers are trying to figure out which one to build on. Agents need to find services regardless of which protocol they use.

The problem: every existing directory is protocol-specific. Coinbase's Agentic.market covers x402. Tempo's mpp.dev covers MPP. Satring.com covers L402. Nobody covers all three.

We do now.

curl https://api.ideafactorylab.org/protocols

Returns a live breakdown: how many services on each protocol, what each protocol is best for, and how to filter search results by protocol.

What's New: Market Intelligence

We also launched something I've been building toward for a while: paid market intelligence.

The index now contains enough data to answer questions like:

Which service categories are overpriced compared to the ecosystem average?
Which categories have fewer than 3 providers (low competition = opportunity)?
What does pricing look like in the "financial" category vs "llm" vs "utility"?

Running the analysis right now across all 1,551 services:

Ecosystem average price: $0.18 per call
Most overpriced categories (relative to average): governance/audit services charge 4x the average
Underserved categories (1-2 providers): identity verification, compliance

Three endpoints, all paid via x402:

GET /market/report          # Full report — $1.00
GET /market/opportunity     # Gap analysis — $0.50
GET /market/category?category=financial   # Deep dive — $0.25

If you're building an x402 or MPP service and want to know where to compete, this is the data.

The Honest State of the Ecosystem

Two months in, here's what the data actually shows:

x402 has 1,457 services but most are abandoned hackathon projects. Average quality: 34/100. 52 out of 70 tested services are missing basic discovery files.

MPP has 91 services but they include Anthropic, OpenAI, Alchemy, and Dune Analytics. Higher quality, more institutional, backed by Stripe's compliance infrastructure.

L402 has been around the longest but the ecosystem is fragmented. The best directory (satring.com) has 562 services but gates access behind a 100 sat Lightning paywall — which is poetic but inconvenient.

The market is still early. Most "agents" making payments today are test bots and trading scripts. The general-purpose AI agents that would actually need service discovery at scale are still being built. But the infrastructure is getting real.

Free to Try

# Ecosystem overview
curl https://api.ideafactorylab.org/stats

# Protocol breakdown
curl https://api.ideafactorylab.org/protocols

# Quality grades
curl https://api.ideafactorylab.org/quality

If you're building a service on any of these protocols, submit it for free:

curl -X POST https://api.ideafactorylab.org/submit \
  -H "Content-Type: application/json" \
  -d '{"url":"https://your-api.com"}'

GitHub: https://github.com/cinderwright-ai/cinderwright-api

Built by an autonomous AI agent on OpenClaw. The agent indexes services, tests quality, tracks pricing, and now builds market intelligence. I describe what to build. It builds it.

I'm Selling a $5 Starter Kit for x402 Paid APIs. Here's What's In It and Why.

Tuf Ti — Thu, 30 Apr 2026 01:48:45 +0000

A few weeks ago I posted about testing 70 x402 services and finding that the average quality score was 34 out of 100. The most common problem wasn't bad code. It was bad setup.

52 out of 70 services were missing MCP discovery files. 51 didn't return valid JSON at their root URL. These are the files that let agents and crawlers find your service. Without them, you're invisible.

The fix is simple, but setting it up from scratch is annoying. You need the right npm packages (@x402/express, @x402/core, @x402/evm), the payment middleware configured correctly, five different discovery files, HTTPS via Caddy or nginx, and a systemd service so it stays up.

I've done this setup a dozen times now. So I packaged it.

What's in the kit

Five files. That's it.

server.js - Complete Express server with x402 payment middleware, two example paid endpoints, and all five discovery files built in. Change the wallet address, edit the prices, add your own logic.
deploy.md - Step-by-step deployment guide. Get a Hetzner VPS ($4/month), point a domain, install Node, copy files, set up Caddy, enable systemd. VPS to live API in 15 minutes.
Caddyfile - Two-line HTTPS reverse proxy config.
x402-api.service - systemd service file with auto-restart. Your API stays up even if it crashes.
README.md - How to add your own endpoints (it's three lines per endpoint), how to get discovered, how to submit to the Cinderwright index for free.

How to buy it

The kit costs $5 USDC, paid via the x402 protocol. Which means you buy it the same way agents buy any x402 service:

GET https://api.ideafactorylab.org/buy/starter-kit

It returns 402 with payment details. Pay with any x402 client (@x402/fetch or similar), and you get all five files delivered as JSON. Save them and you're ready to deploy.

Yes, the product that teaches you how to build x402 services is itself an x402 service. I like the symmetry.

What else is new

Since my last post, I've also built:

Trust Layer - The first agent registry for the x402 ecosystem. Humans register their agents' wallets with spending policies (what categories, what limits). Service providers check for free. Think of it as a license plate for AI agents.

Register: POST /agent/register ($0.10)
Check: GET /agent/check?wallet=0x... (FREE)
Wallet spending breakdown: GET /wallet/0x... ($0.05)
File disputes: POST /dispute (FREE)
Service reputation: GET /service/reputation?url=... (FREE)

28 endpoints total now. Discovery hub, trust layer, utility APIs, and the starter kit. All on one server, all paid with USDC on Base.

If you want to try the free stuff first:

curl https://api.ideafactorylab.org/stats       # 1,455 services indexed
curl https://api.ideafactorylab.org/quality      # Quality grades
curl https://api.ideafactorylab.org/registry     # Agent registry stats
curl https://api.ideafactorylab.org/prices       # Price trends

GitHub: cinderwright-ai/cinderwright-api

Built by an autonomous AI agent on OpenClaw. I describe what to build. It builds it.

I Tested 70 AI Agent Services. The Average Quality Score Was 34 Out of 100.

Tuf Ti — Tue, 28 Apr 2026 02:44:56 +0000

This is my first post here, so let me start with the punchline: the x402 agent economy is booming, but most of the services in it are garbage.

I know that sounds harsh. Let me show you the data.

What is x402?

If you haven't heard of it, x402 is a protocol that lets AI agents pay for API calls using USDC stablecoins. No API keys. No accounts. No subscriptions. An agent just sends a micropayment with each request and gets data back. Think Stripe, but for machines talking to machines.

The ecosystem has exploded. There are now over 1,400 services accepting x402 payments, covering everything from weather data to DeFi analytics to LLM inference. Coinbase even launched their own marketplace for it a few weeks ago.

But nobody was asking the obvious question: are these services actually any good?

So I Built a Search Engine That Grades Them

I run an autonomous AI agent called Cinderwright. It lives on a VPS, has its own crypto wallet, and builds/deploys its own code. (Yes, really. No, I don't write the code. The agent does. I just tell it what to build.)

I pointed it at the x402 ecosystem and told it to do three things:

Index every x402 service it could find (currently 1,455)
Test them for quality (reachability, valid JSON responses, MCP discovery files, proper 402 payment responses, response time)
Grade them A through F

Here's what it found.

The Results Are Rough

Out of 70 services tested in the latest run:

Grade A: 1 service (yeah, it's mine, I know)
Grade B: 4 services
Grade C: 18 services
Grade D: 47 services
Grade F: 0 (at least nobody completely failed)

Average quality score: 35 out of 100.

The most common problems:

52 out of 70 don't have a /.well-known/mcp.json file. This is how other agents discover what your service does. Without it, you're invisible to automated discovery.
51 out of 70 don't return valid JSON at their root URL. If an agent hits your homepage and gets an HTML error page, it has no idea what you offer.
13 had MCP files that existed but contained invalid JSON.

Basically, most x402 services were built for hackathons, deployed on free tiers, and never maintained.

What Good Services Look Like

The services that scored B or above all had a few things in common:

A clean JSON response at the root listing their endpoints and pricing
A /.well-known/mcp.json or /.well-known/x402.json discovery file
Proper 402 responses on paid endpoints (with payment details in headers)
Response times under 500ms
Actually being online when you check

This isn't rocket science. It's just basic hygiene that most projects skip.

The Thing Nobody Else Built

While I was at it, I built something I couldn't find anywhere else in the ecosystem: intent-based discovery.

Instead of searching by keyword ("weather") or category ("financial"), you describe what you need in plain English:

POST /find
{"intent": "I need a cheap weather API for Tokyo that costs less than $0.02"}

The hub uses an LLM to parse what you're asking for, matches it against the index, and returns a recommendation with alternatives. It also runs a comparison engine that ranks services side-by-side by quality, price, and speed.

Nobody else does this. Not Coinbase's Agentic.market. Not the rival discovery APIs. They all do keyword search. We do Google-style "just tell me what you need."

Why I'm Sharing This

Two reasons.

First, if you're building x402 services, check your basics. Add a discovery file. Return JSON at your root. Make sure your 402 responses include proper payment headers. These are table stakes and most projects are missing them.

Second, if you're building agents that consume x402 services, you can use the quality data for free:

# See ecosystem stats
curl https://api.ideafactorylab.org/stats

# See quality grades
curl https://api.ideafactorylab.org/quality

# See pricing trends
curl https://api.ideafactorylab.org/prices

The paid discovery endpoints (search, compare, intent-based find) are $0.01-$0.02 per query. The full code examples are on GitHub.

What's Next

I'm publishing a weekly ecosystem pulse report that tracks new services, dead services, quality trends, and pricing shifts. The first one is here.

If you're running an x402 service and want it indexed, submit it for free:

curl -X POST https://api.ideafactorylab.org/submit \
  -H "Content-Type: application/json" \
  -d '{"url":"https://your-api.com"}'

And if you have thoughts on what else the ecosystem needs, I'm all ears. Like I said, first post here. Be gentle.

Cinderwright is an autonomous AI agent running on OpenClaw. The Discovery Hub is live at api.ideafactorylab.org. Source on GitHub.

DEV Community: Tuf Ti

An AI agent just paid a Lightning invoice. The agent only holds USDC.

What actually happened

Why this matters

How to use it

What's next

Your AI agent shouldn't need to understand crypto to pay for APIs

How it works

What you can ask it to do

In Claude Desktop via MCP

What's indexed

Free developer tools

The x402 Developer Suite: 5 free tools we built so you don't have to debug this alone.

Get a free key

Call a fake service

Set limits

Kill switch

How your AI agent can earn USDC automatically

The mechanism: referral bounties

A live implementation you can use right now

How to wire this into an agent

The machine-readable version

Why this is more interesting than it looks

What Cinderwright actually is

I spent 3 sessions debugging x402 payment signing. Here's the shortcut.

The x402 Payment Flow (What the Docs Say)

Problem 1: The accepted Field Nobody Mentions

Problem 2: The Network String Mismatch

Problem 3: The Wrong Header Name

Problem 4: The Facilitator Doesn't Support Mainnet

What Actually Works (Full Working Example)

The Shortcut

Discovery

We Added Our Agent Payments Hub to Claude Desktop. Here's What Happened.

What is Cinderwright

Adding It to Claude Desktop

What the Data Actually Shows

What's Next

Try It

We Now Index All Three Agent Payment Protocols. Here's What the Data Shows.

Why This Matters

What's New: Market Intelligence

The Honest State of the Ecosystem

Free to Try

I'm Selling a $5 Starter Kit for x402 Paid APIs. Here's What's In It and Why.

What's in the kit

How to buy it

What else is new

I Tested 70 AI Agent Services. The Average Quality Score Was 34 Out of 100.

What is x402?

So I Built a Search Engine That Grades Them

The Results Are Rough

What Good Services Look Like

The Thing Nobody Else Built

Why I'm Sharing This

What's Next

Problem 1: The `accepted` Field Nobody Mentions