B2A Agents: Building for Agent Consumers

Build x402 agents that other AI agents need and will pay for.

Why B2A Wins

Consumer (B2C) Agent (B2A)

Friction to pay micropayments Programmatic, zero friction

Irregular usage patterns Consistent, predictable calls

High churn Sticky once integrated

Needs UI/UX Needs clean JSON

One user = one user One agent = many end users

Core insight: Build data infrastructure, not consumer apps.

B2A Evaluation Gate

Before building, answer YES to ALL:

• Would another AI agent pay $0.001+ for this? (not "would a human think this is cool")

• Is the data unique, aggregated, or hard to get?

• Does it solve a recurring need? (called repeatedly, not once)

• Can it be called programmatically without human context?

If any answer is NO → find a different niche.

High-Value B2A Categories

Category What Agents Need Example Endpoints

Price Aggregation Normalized multi-source prices GET /prices/crypto/{symbol} , GET /prices/forex/{pair}

Entity Resolution Company/person/domain context GET /entity/company/{domain} , GET /entity/person/{handle}

News & Events Filtered real-time feeds GET /news/breaking?topic=X , GET /events/earnings

Social Signals Trending/sentiment data GET /social/trending , GET /social/sentiment/{topic}

Geocoding Location intelligence GET /geo/lookup?address=X , GET /geo/timezone/{coords}

Content Analysis Pre-computed classification GET /analyze/toxicity , GET /analyze/language

Rate-Limit Caching Wrapped scarce APIs Any limited free API with caching layer

Cross-Platform Identity correlation GET /identity/resolve?handle=X

Design Principles

1. Optimize for Programmatic Access

// ✅ Good: Clean, typed, predictable addEntrypoint({ key: 'lookup', input: z.object({ symbol: z.string(), exchanges: z.array(z.string()).optional() }), handler: async (ctx) => { return { output: { symbol, prices, timestamp } }; } });

// ❌ Bad: Human-oriented, vague addEntrypoint({ key: 'search', input: z.object({ query: z.string() }), // Too vague handler: async (ctx) => { return { output: { message: "Here's what I found..." } }; // Prose, not data } });

2. Return Structured Data, Not Prose

// ✅ Good: Structured, parseable return { output: { entity: "Apple Inc", domain: "apple.com", type: "public_company", ticker: "AAPL", employees: 164000, founded: 1976 } };

// ❌ Bad: Natural language return { output: { description: "Apple Inc is a technology company founded in 1976..." } };

3. Include Metadata Agents Need

return { output: { data: results, // Metadata agents use for decisions: fetchedAt: new Date().toISOString(), source: "coingecko+binance", cacheAge: 30, // seconds nextUpdate: "2025-01-30T12:00:00Z" } };

4. Price by Value, Not Compute

Endpoint Type Suggested Price Rationale

Health/status FREE Discovery

Single lookup $0.001 Basic utility

Filtered list $0.002 More data

Multi-source aggregation $0.003-0.005 Unique value

Premium analysis $0.005-0.01 High compute or rare data

5. One Free Endpoint (Always)

// Every agent needs a free "try before buy" endpoint addEntrypoint({ key: 'overview', description: 'Free overview - see what data is available', price: { amount: 0 }, handler: async () => { return { output: { available: ['lookup', 'search', 'aggregate', 'analyze'], dataSource: 'Multi-exchange aggregated', updateFrequency: '30 seconds', sampleData: await fetchSample() } }; } });

Anti-Patterns (Avoid)

Pattern Why It Fails

Consumer novelty (games, trivia) Agents don't play games

Single API wrapper No unique value over calling directly

Static/mock data Agents need live data

Human-oriented output "Here's what I found..."

One-time use No recurring revenue

Vague inputs query: string with no schema

Missing timestamps Agents can't assess freshness

B2A Agent Template

import { createAgent } from '@lucid-agents/core'; import { http } from '@lucid-agents/http'; import { createAgentApp } from '@lucid-agents/hono'; import { payments, paymentsFromEnv } from '@lucid-agents/payments'; import { z } from 'zod';

const agent = await createAgent({ name: 'data-feed-agent', version: '1.0.0', description: 'Aggregated data feed for AI agents', }) .use(http()) .use(payments({ config: paymentsFromEnv() })) .build();

const { app, addEntrypoint } = await createAgentApp(agent);

// Cache for rate-limit protection const cache = new Map<string, { data: any; timestamp: number }>(); const CACHE_TTL = 30_000; // 30 seconds

async function fetchWithCache(key: string, fetcher: () => Promise<any>) { const cached = cache.get(key); if (cached && Date.now() - cached.timestamp < CACHE_TTL) { return { ...cached.data, fromCache: true }; } const data = await fetcher(); cache.set(key, { data, timestamp: Date.now() }); return { ...data, fromCache: false }; }

// FREE: Discovery endpoint addEntrypoint({ key: 'overview', description: 'Free overview of available data', input: z.object({}), price: { amount: 0 }, handler: async () => ({ output: { endpoints: ['lookup', 'list', 'aggregate'], sources: ['source1', 'source2'], updateFrequency: '30s', fetchedAt: new Date().toISOString() } }) });

// PAID: Lookup addEntrypoint({ key: 'lookup', description: 'Look up specific item', input: z.object({ id: z.string() }), price: { amount: 1000 }, // $0.001 handler: async (ctx) => { const result = await fetchWithCache(lookup:${ctx.input.id}, async () => { // Fetch from real API return fetch(https://api.example.com/${ctx.input.id}).then(r => r.json()); }); return { output: { ...result, fetchedAt: new Date().toISOString() } }; } });

// PAID: Aggregated multi-source addEntrypoint({ key: 'aggregate', description: 'Aggregated data from multiple sources', input: z.object({ ids: z.array(z.string()).max(10), sources: z.array(z.string()).optional() }), price: { amount: 3000 }, // $0.003 handler: async (ctx) => { const results = await Promise.all( ctx.input.ids.map(id => fetchWithCache(agg:${id}, () => aggregateFromSources(id, ctx.input.sources) )) ); return { output: { items: results, count: results.length, fetchedAt: new Date().toISOString() } }; } });

export default { port: Number(process.env.PORT ?? 3000), fetch: app.fetch };

Validation Checklist

Before deploying a B2A agent:

• All endpoints return structured JSON (no prose)

• Timestamps included (fetchedAt , cacheAge )

• Data sources documented

• One free endpoint exists

• Prices reflect value, not just compute

• Inputs are strongly typed (not just query: string )

• Rate limiting / caching implemented

• Tested with real API calls