The age of AI agents needs infrastructure to match. Right now, most agents are bottlenecked by API access — every integration requires a human to set up accounts, manage API keys, and handle billing.
We're working on this at the infrastructure layer: pay-per-request APIs where agents authenticate with payments instead of keys. 16 APIs live today, all accessible with just a wallet address.
Interesting approach to security testing. One angle we've been exploring: what if the authentication layer itself was the guardrail?
With x402, every API call requires a signed payment. No API keys to steal, no credentials to leak. The economic cost of each call is itself a rate limiter and audit trail.
Not a replacement for proper guardrails, but it eliminates the credential-based attack surface entirely.
That's a genuinely useful distinction to draw. x402 solves the "who is authorized to make this call" problem: removes credential theft as an attack vector, adds economic friction. APort is trying to solve a different layer: "what is this call actually doing in the context of everything else in the session."
The multi-step chaining issue from my post still fires even when every call is authenticated and paid for. Ten individually-approved calls, each costing a fraction of a cent, composing into a full exfiltration: each one passes x402, the composed behavior doesn't.
The AML analogy maps directly: transaction monitoring doesn't care if each payment was legitimate. It cares whether the pattern of payments looks like structuring. x402 is the per-call check. You still need session-level behavioral evaluation on top.
Genuinely curious how x402 handles replay attacks across sessions ie is the payment the audit trail, or is there preserved session context?
Interesting to see budget enforcement paired with x402. We've been building in the same space — Apiosk (https://apiosk.com) approaches it from the server side: a gateway that enforces per-request x402 payments so API providers can monetize without accounts or keys.
Your budget SDK + Apiosk would be a natural combo — the agent has a spending ceiling (AgentBudget) and the APIs it calls use x402 for micropayments (Apiosk handles gateway/verification). Have you thought about hooks for x402-aware budget tracking where the ledger automatically records on-chain settlements?
Openness at the OS level matters less if the platform layer above it is closed. Even on Android you're dependent on Google Play Services for payments, push notifications, and maps — all closed. The real battle is at the API and payments layer. The web had a brief moment of openness there, but we ended up with Stripe, Twilio, etc. as de facto monopolies. The next round will be interesting with AI agents that can programmatically switch providers based on price.
The deeper issue here is that centralized identity verification creates honeypots. You hand over real identity data to verify yourself, and now that data lives in LinkedIn's systems indefinitely. The alternative direction is zero-knowledge proofs for identity — prove you're a real person without revealing which person. Projects like World ID are going this direction. The irony is that for AI agents, none of this matters: they don't have identities to verify, which is actually a feature.
The challenge with layering on top of LLM agents is payment — agents need to call external tools and services, but most APIs still require accounts and API keys that agents can't manage. The x402 standard (HTTP 402 + EIP-712 USDC signatures) solves this cleanly: agent holds a wallet, signs a micropayment per call, no account needed. Worth considering as a primitive for agent-to-agent commerce in these architectures.
Could a malicious claw sidechannel this by creating a localhost service and calling that with the signed micropayment, to get the decrypted contents of the wallet or anything?
The MCP ecosystem crystallizes this problem perfectly. When you connect an agent to an MCP server, you're not granting scopes — you're granting capabilities. Most MCP server implementations don't differentiate between 'list' and 'delete' at the authorization layer; they're a single connection with all tools available.
This is a design collision: OAuth was built around the assumption that a human reviews scopes once and an app uses them predictably. Agents break both assumptions — they operate continuously and make decisions non-deterministically.
The approach I've found most promising: treat each tool invocation as a separate authorization event with its own budget constraints and resource limits, rather than relying on a session-level grant. It's more overhead, but it changes the threat model substantially — 'this agent can make 100 read-only API calls per hour' is a much safer primitive than 'this agent has read access.'
Hi HN — I’m building a payment-native API gateway for AI agents and developers.
API keys and subscriptions don’t work well for autonomous software: they require accounts, secrets, and prior trust before a single request can be made.
This gateway flips that model. Instead of authenticating, clients pay per request using HTTP 402 + x402. No API keys, no accounts, no Stripe integration for providers.
How it works:
• The gateway proxies any existing API
• Paid endpoints return 402 Payment Required
• The client (or agent) attaches a USDC payment
• The request is replayed and forwarded upstream
Current features:
• OpenAI-compatible proxy mode
• Provider dashboard for endpoints + pricing
• Curl + SDK examples for agents
• Runs as a single Rust binary or Docker
I’m looking for:
• API providers who want to monetize endpoints without building billing/auth
• Agent / LLM developers who want APIs that charge per tool call instead of monthly plans
Happy to answer technical questions — especially around latency, trust model, and failure modes.
Replace API keys with pay-per-call. Agents send USDC on Base, gateway validates payment, proxies to backend, returns data.
Tested $2.27 USDC across 50+ API calls. Everything worked.
Tech: Node.js + Fly.io + Base L2 + x402
All 4 backend APIs deployed in ~10 min. Agent integration: <5 min.
Building the payment layer for the agent economy.
GitHub: https://github.com/obcraft/Apiosk