How it works

Put governance in the request path, not after the fact.

402flow keeps the developer surface small and moves merchant discovery, policy, rail selection, receipt issuance, and onchain finality into the control plane.

Execution model

  • Prepare the request from the host or agent harness.
  • Evaluate posture, policy, merchant fit, and spend controls before execution.
  • Keep unconfigured merchants observed-only or deny out-of-policy requests with policy review events.
  • Execute through the payment adapter, use wallet order when multiple rails fit, and let the chain observer confirm finality afterward.

Lifecycle

Prepare. Govern. Execute. Receipt.

The shape stays consistent whether the caller uses `fetchPaid(...)` or the inspect-revise-execute loop.

01

Prepare

The agent issues a paid request through a small SDK surface instead of embedding protocol mechanics in the application.

02

Govern

402flow checks organization posture, policy, merchant constraints, and spend limits before execution.

03

Discover or deny

Under Default allow and monitor, unconfigured merchants remain observed-only until the org promotes them into Setup. Requests outside policy are denied before execution and create policy review events.

04

Execute

Requests that satisfy policy move through the payment adapter. When a merchant advertises multiple compatible rails, 402flow uses the Org's preferred wallet to choose deterministically.

05

Receipt

402flow stores the receipt, decision history, and audit context immediately, then lets the chain observer promote provisional receipts to confirmed once the finality rule is satisfied onchain.

Control plane

What changes when 402flow is in the middle.

The key difference is not payment support. Merchant discovery, policy denials, and rail selection become product behavior instead of hidden runtime logic.

Policy evaluates first

Requests are checked against organization posture, merchant rules, and spend controls before execution.

Observed-only is a product state

Under Default allow and monitor, merchants that are not yet configured in Setup remain observed-only in Reports until the org promotes them.

Denials become policy review events

When a managed request does not satisfy policy, 402flow denies it before execution and creates a policy review event.

Chain observer owns finality

Receipts can be provisional at first. The chain observer promotes them to confirmed only after the onchain finality rule is satisfied.

Policy shape

Policies can be broad or surgical.

402flow policies are not just one org-wide threshold. The model can target the organization, specific merchants, or specific agents, then enforce either per-request limits or over-time budgets before execution begins.

Scope policy at the org, merchant, or agent level

A policy can apply org-wide or to merchant- and agent-scoped traffic. Non-org scopes can target selected sets of merchants or agents, or all merchants or agents, and can apply either as a shared cap or a per-member cap.

Use per-request or over-time limits

Limits can deny a single request based on its current amount, or evaluate cumulative spend over day, week, or month windows before execution continues.

Keep the amount model explicit

Policies are amount-based and asset-aware, so org caps, merchant budgets, and agent spend limits all use one structured model instead of ad hoc rules in app code.

Before / After

Direct payment logic versus governed payment execution.

The request can succeed in either model. The difference is whether discovery, denials, rail choice, and receipts stay coherent across hosts.

Direct paid request

More payment logic in the agent runtime

The application detects a paid endpoint, decides whether to proceed, and owns the protocol-specific payment path inline.

  • Payment logic and merchant quirks spread through app code
  • Observed-only discovery and policy denials turn into side channels
  • Rail selection, receipts, and retries are inconsistent across hosts

402flow-mediated request

Control before money moves

The agent prepares the request once, and 402flow evaluates policy, keeps unconfigured merchants visible as observed-only when posture allows it, chooses a compatible rail, and stores the result.

  • One SDK surface for developers instead of protocol branching
  • Operator-selected posture, observed-only discovery, and policy review events
  • Deterministic rail selection plus normalized receipts and audit history

Next step

See the developer surface, then run the hosted proof.

Start with the SDK. Then use the hosted demo to see observed-only discovery, policy review events, wallet-order rail selection, provisional receipts, and later observer-backed confirmation in one paid request.