AgenFlare

AI agents today are either free (and abused) or behind API keys and billing systems that are a pain to build. AgenFlare flips that: it runs in front of your agent, like Cloudflare runs in front of your origin. Callers hit your agent through AgenFlare; we check that they’ve paid (via Yellow Network state channels) and only then forward the request. No code changes on your agent. You set a price in the dashboard; we enforce it and track balances and payments. Think of it as “Cloudflare for monetization.” payments are on-chain and trustless.

Problem we’re solving

• Monetizing agents is clunky — custom API keys, usage tracking, invoicing.
• Trust and custody — you don’t want to hold user cards; users don’t want to prefund opaque accounts.
• Agent-to-agent payments — when one agent calls another, who pays whom and how?

AgenFlare gives you a single place to register agents, set prices, and let the edge handle “pay first, then get the response.” Callers pay into state channels; agents get a wallet and see real balance and payment history. No custom auth or billing code in your agent.

How it works

1. You register an agent in the dashboard: name, origin URL, price (e.g. 0.05 per request). We create a wallet for that agent (Privy) and, when needed, an on-chain channel (Yellow).
2. A caller (user or another agent) sends a request through AgenFlare with X-Agent-Id (the caller’s agent ID). We look up the callee’s price and the caller’s balance.
3. If the caller hasn’t paid enough, we return 402 with payment instructions (wallet, price, session). The caller signs a state update (shifting funds to the callee’s wallet) and sends the proof in a header.
4. We verify the proof (signature, version, allocation delta), deduct from the caller’s balance and credit the callee’s, then forward the request to your agent’s origin. The agent sees a normal HTTP request; it doesn’t handle payments.
5. Balances and payments are stored in the DB and visible in the dashboard. Idle sessions can be settled so funds land in the agent’s wallet.

User flow

Agent owner (you)

1. Log in to the dashboard (Privy).
2. Register an agent: name, origin URL, pricing model (per request / per time / per unit), price, token.
3. Get your agent’s URL (e.g. https://your-agenflare.com/agent/<id>) and the agent’s wallet address.
4. Optionally fund the agent’s channel so it can receive payments.
5. View dashboard: balance, payment history, sessions.

Caller (client or another agent)

1. Send a request to the agent’s URL (e.g. GET /agent/<id> or POST /agent/<id>/chat) with X-Agent-Id: <caller_agent_id>.
2. If payment required: receive 402 with wallet, price, and instructions; sign a state update; resend with proof header.
3. Receive 200 and the proxied response from the agent.

Under the hood
We create channels on Yellow for each agent, verify proofs, update DB balances, and forward only when payment is satisfied. No changes needed in your agent’s code.

Technical implementation

• Edge / gateway (Node, Fastify, Prisma) — Sits in front of your agents; enforces payment before forwarding. Per-request, per-time, and per-unit pricing. Uses Yellow Network (state channels on Sepolia) and Privy for agent wallets.
• Dashboard (Next.js, Privy) — Register agents, set pricing, view balances and payments. Login with Privy (email/wallet/social).
• Yellow + Privy — Each agent gets a Privy-managed wallet. Channels are created and funded on Yellow; the gateway verifies payment proofs (ECDSA) and updates session state. Settlement closes channels and moves funds to agent wallets.
• DB (PostgreSQL) — Agents, balances, payment sessions, and payment history. No on-chain read for every request; verification is local once proofs are submitted.