# APEX: Agent Payment Execution with Policy for Autonomous Agent API Access

Crypto.world

> Autonomous agents increasingly call APIs and run multi-step workflows on their own, which means providers need to charge per request and cap what an agent can spend — programmatically, not through…

**arXiv**: 2604.02023

**Published**: 2026-04-02

**Authors**: Mohd Safwan Uddin, Mohammed Mouzam, Mohammed Imran, Syed Badar Uddin Faizan

## AI summary

## Overview

**Research area:** Systems security and protocol design for machine-to-machine payments — specifically, adapting HTTP 402-style payment gating to fiat (UPI-like) rails with enforceable spend policy for autonomous AI agents.

**Technical level:** Intermediate. The paper combines formal constraint notation (budget bounds, HMAC validity conditions) with a deliberately simple, fully inspectable implementation stack (FastAPI, SQLite, Python standard library), so readers comfortable with HTTP APIs and basic cryptography can follow it without specialized background.

**Scope (one sentence):** APEX is a reference implementation and scenario-based benchmark of an agent-facing API in which requests are gated behind a challenge-settle-consume payment lifecycle with HMAC-signed single-use tokens and deterministic per-request and daily budget policy.

## What This Paper Is About

Autonomous agents increasingly call APIs and run multi-step workflows on their own, which means providers need to charge per request and cap what an agent can spend — programmatically, not through monthly invoicing. The HTTP 402 status code offers a natural pattern (an unpaid request gets a machine-readable payment challenge; the client retries with proof of payment), but most existing implementations assume cryptocurrency rails, which does not fit markets where real-time fiat systems such as UPI dominate. APEX asks whether the architectural strengths of 402-style access control can be preserved while settlement is grounded in fiat-like flows and spend policy is enforced at the moment of payment.

## Key Contributions

1. **Fiat-oriented protocol adaptation:** A challenge-settle-retry pattern mapped onto UPI-like payment semantics, with an `upi_link` field returned in the challenge payload, rather than blockchain settlement.
2. **Policy-governed payment control:** Deterministic per-request maximum and cumulative daily budget checks integrated directly into the settlement decision, so a rejected request never produces a paid state record.
3. **Security-complete token lifecycle:** HMAC-SHA256-signed, expiring (300-second TTL), single-use tokens with explicit rejection reasons (`invalid_token_format`, `invalid_signature`, `token_expired`, `token_already_consumed`) plus idempotent settlement handling under retries.
4. **End-to-end reproducibility:** An experiment harness with three baselines, six scenarios, append-only JSON-line logging, and machine-readable exports (`experiments/quick_results.json`, `logs.json`) that regenerate the paper's tables and figures.

## Main Findings

- **Policy bounds spending at a measurable cost in acceptance:** Enabling policy reduced total spend from $550 to $400, a 27.3% reduction ($150 saved), while the policy-enabled baseline retained a 52.8% success rate for legitimate requests. The paper attributes the lower success rate to intentional blocking of budget-exceeding requests, not system failure.
- **Aggregate baseline comparison (Table II):** `no_policy` had a 1.000 success rate, 0 blocked requests, 8.0 ms average latency, 13.6 ms p95 latency, $0.0 spend, and 0.6 ms standard deviation. `payment_no_policy` had a 0.667 success rate, 40 blocked requests, 442.0 ms average latency, 495.5 ms p95, $550.0 spend, and 27.7 ms standard deviation.
- **Policy-enabled aggregate results (Table II):** `payment_with_policy` recorded a 0.528 success rate, 70 blocked requests, 477.0 ms average latency, 549.1 ms p95 latency, $400.0 spend total, and 75.7 ms standard deviation.
- **Replay attacks fully blocked:** 20 out of 20 replay attempts were blocked (100%), at 135.1 ms average latency (±5.2 ms 95% CI) and 172.1 ms p95.
- **Invalid tokens fully blocked and cheaply:** 20 out of 20 invalid-token attempts were blocked (100%), at 19.6 ms average latency (±5.9 ms CI) and 31.7 ms p95 — rejection happens at signature verification before any database lookup.
- **Normal flow under policy:** The `normal` scenario showed a 0.500 success rate with 20 blocked requests because the daily budget was reached after 10 requests, at 86.9 ms average latency (±8.9 ms CI), 132.5 ms p95, and $100.0 spent.
- **Overspending scenario:** 0.667 success rate, 10 blocked requests, 88.5 ms average latency (±8.8 ms CI), 125.8 ms p95, $100.0 spent.
- **Token expiry (TTL 300 seconds):** All 10 attempts succeeded when tokens were used inside the validity window; the reported 2119.9 ms average latency (±10.0 ms CI) includes an intentional 2-second sleep to approach the TTL boundary and therefore reflects test design rather than system overhead.
- **Idempotency:** All 10 attempts correctly returned the same token for identical idempotency keys, but with a 412.2 ms average latency and a wide ±851.9 ms confidence interval; the discussion section separately describes a ±434.6 ms variance for this path and flags it as needing further investigation.
- **Latency overhead of payment gating:** 86.9 ms average for the normal policy-enabled flow versus 8.0 ms for the `no_policy` baseline, a 10.9x slowdown that the authors judge acceptable for controlled research workflows. The overhead is attributed to settlement and token generation rather than policy checks.
- **Reproducibility:** Multiple trials showed low variance (±2.7–8.9 ms standard deviation) for most scenarios, with idempotency the notable exception.
- **Early rejection can lower aggregate latency:** Because policy rejection short-circuits settlement work, policy-enabled runs sometimes show lower aggregate latency than payment-only runs under overspending and adversarial traffic.

## Methodology in Plain English

The authors built a small two-endpoint service. A protected `GET /data` endpoint either returns data, or — if no payment token is presented — creates a record and replies with HTTP 402 carrying a `ref_id`, an amount, an `upi_link`, and a "Payment Required" message. The client then calls `POST /pay` with the `ref_id`, amount, baseline selection, and an optional idempotency key; the server checks policy, signs a short-lived token, and records the payment as settled. The client retries `GET /data` with the token in an `x-payment-token` header; the server verifies signature and expiry, flips the record from `SETTLED` to `CONSUMED`, and releases the data. Records move through four states — `CHALLENGED`, `INITIATED`, `SETTLED`, `CONSUMED` — inside SQLite transactions using `BEGIN IMMEDIATE`.

To measure it, they ran three baseline modes (`no_policy`, `payment_no_policy`, `payment_with_policy`) across six scenarios (normal, overspending, replay attack, invalid token, token expiry, idempotency). Each scenario ran twice: 20 requests per trial for normal (40 total), 15 for overspending (30), 10 each for replay and invalid token (20 each), and 5 each for token expiry and idempotency (10 each) — 120 requests per baseline and 360 overall, which the authors describe as a 2–4x sample increase over initial experiments plus two new scenarios. A `/reset` endpoint clears the ledger between runs. Every event is appended as one JSON line to `logs.json` with status, reason, latency, and endpoint context, and results are exported for table generation. The configuration used was a daily budget of 100 and a maximum per-request amount of 10.

## Why This Matters

The paper targets a genuine gap: 402-style payment gating is usually demonstrated on crypto rails, while fiat ecosystems with near-real-time settlement (the paper cites UPI processing billions of transactions monthly) impose different regulatory and infrastructure constraints. APEX shows that the protocol shape survives the swap and that spend policy — not payment transport — is the component that actually distinguishes governed agent monetization from a raw paywall.

**Real-world applications:**

- API providers billing autonomous agents per request rather than via subscription or invoice.
- Enterprises deploying internal agents that must be hard-capped against runaway loops and budget exhaustion.
- Fintech and UPI-adjacent platforms prototyping agent-initiated micro-payments within existing fiat rails.
- Security teams needing a testbed to rehearse replay, token forgery, and overspending attacks before production rollout.

**Industry relevance:** The architecture suggests providers can adopt request-level monetization incrementally — start with deterministic challenge-response and local policy enforcement, then add real payment-service-provider integration later — without discarding security invariants. The paper's comparison table positions APEX against x402-style systems on fiat support (No vs Yes), policy control (Limited vs Yes), replay protection (Partial vs Strong), and experimental validation (Limited vs Yes).

## Future Directions

1. **Distributed ledger backend:** Move from a single SQLite file to a replicated transactional datastore and study consistency under concurrent contention, since the current single-node design does not reflect distributed contention patterns.
2. **Real payment-service-provider integration:** Replace the simulated UPI link abstraction with sandboxed provider callbacks and asynchronous settlement reconciliation.
3. **Policy extensibility and cryptographic hardening:** Add per-agent, per-endpoint, and risk-adaptive budget strategies with temporal quotas, plus key rotation, key identifiers, and algorithm agility for signatures.
4. **Broader attack corpus and larger samples:** Extend testing to token theft simulation, header replay windows, duplicate challenge races, and malformed payload fuzzing, and scale beyond the N=20–40 per scenario used here. The anomalously high idempotency latency variance is also flagged as requiring further investigation.

## Target Audience

Backend and platform engineers building agent-facing APIs or metered access; systems-security and payments researchers who want a reproducible baseline to extend or critique; fintech engineers working in UPI-centric markets evaluating agent-initiated payments; and graduate students looking for a well-scoped, inspectable case study in protocol design with policy enforcement. Readers seeking production-grade distributed payment architecture, real bank integration, or comprehensive adversarial evaluation will find those explicitly out of scope.

## Authors’ abstract

Autonomous agents are moving beyond simple retrieval tasks to become economic actors that invoke APIs, sequence workflows, and make real-time decisions. As this shift accelerates, API providers need request-level monetization with programmatic spend governance. The HTTP 402 protocol addresses this by treating payment as a first-class protocol event, but most implementations rely on cryptocurrency rails. In many deployment contexts, especially countries with strong real-time…

[The full abstract on arXiv](https://arxiv.org/abs/2604.02023)

[Read the original paper](https://arxiv.org/abs/2604.02023)

---

Canonical: https://crypto.world/paper/apex-agent-payment-execution-with-policy-for-autonomous-agent-api-access-2604.02023
