When software can pay,
software can act.

Agentic commerce is what happens when you give autonomous software a wallet with rules. The result isn’t a faster workflow; it’s the elimination of the workflow entirely.

What you’re looking at

Agent City runs on Open Agent Access

Agent City is the visible simulation. Open Agent Access is the layer underneath. It shows the papers each agent must carry to act: who they are, what they’re allowed to do, what they’re paying for, and the receipt that proves it happened.

IdentityMandatePurposePolicy decisionBudgetPayment termsReceiptProvenance

This isn’t a mockup: every decision (allow · deny · charge) and every receipt is produced by this site’s live, machine-readable policy on Algorand.

Read the agent-access policy →

The problem is permission, not capability

Most systems already know what to do. A sensor knows a part is running low. A thermostat knows the grid price just spiked. A dispenser knows a prescription needs refilling. The intelligence exists. What doesn’t exist is the authority to act on it.

In every organisation and most households, there’s a gap between detection and action, and that gap is filled with emails, approvals, phone calls, and waiting. We call it process. In practice, it’s dead time: the interval where a system sits idle because it’s waiting for a human to grant permission that was always going to be granted.

Dead time isn’t a minor inefficiency. It’s where factories lose six figures to a $5 part that wasn’t ordered fast enough. It’s where a patient misses a dose because the refill process assumes they’ll remember to act before the need becomes urgent. It’s where a pothole sits for six weeks because the budget approval takes longer than the repair.

What changes when an agent has a wallet

A wallet is not a bank account. In this context, it’s a programmable container with embedded rules: what the agent can spend, under what conditions, with which counterparties, and up to what limit. The wallet doesn’t replace human judgment. It encodes that judgment in advance, so execution doesn’t need a human present.

When an agent has a policy wallet, the permission layer collapses. Detection is action. The inventory sensor doesn’t file a report. It triggers a payment. The energy monitor doesn’t send an alert. It executes a trade. The prescription tracker doesn’t flag a warning. It reorders the medication.

The difference is structural: traditional systems produce information that humans must act on. Agentic systems produce outcomes that humans have pre-authorised.

Why the payment layer matters

There’s a reason this didn’t happen with traditional payment rails. Moving £0.10 through conventional banking costs more than the transaction is worth. A credit card payment requires a merchant account, a processor, a settlement period, and fees that make micro-transactions impossible.

Blockchain-based payment rails change the economics. A payment can settle in seconds for a fraction of a penny. That isn’t interesting because it’s “crypto.” It’s interesting because it makes a category of transaction viable that was previously impossible. An energy agent can trade £0.10 of electricity hundreds of times a day. An infrastructure agent can post a £0.05 bounty to verify a repair. A supply chain agent can pay £5 for a replacement part without the overhead of a purchase order.

The wallet becomes the permission layer, the payment layer, and the audit trail, all in one. Every action an agent takes is recorded, verifiable, and constrained by rules set before the agent was ever deployed.

StageTraditional processWith agentic commerce
DetectionSystem generates an alert or reportAgent identifies the condition and proceeds
DecisionHuman evaluates options manuallyAgent applies pre-set policy logic
ApprovalRouted through management chain (hours to days)Wallet contains the pre-approval (milliseconds)
PaymentInvoice raised, PO issued, card entered manuallyCryptographic payment signed and settled instantly
FulfilmentBegins after administrative cycle completesBegins at the moment the need is identified

This isn’t theoretical

The scenarios below are interactive demonstrations of how this works in practice. Each one follows a real problem through detection, autonomous action, and settlement, showing exactly where traditional processes create dead time and how a policy wallet eliminates it. Step through them to see the mechanics, or read the descriptions to understand the logic.

Try the policy yourself

Every request below is evaluated against this site’s live Open Agent Access policy. Allowed reads pass; AI-training is denied; anonymous agents are asked for a passport; paid actions return a 402 charge.

Summarise a public page

read · research

Scrape to train a model

ai-train · model-training

Anonymous request, no passport

read · research

Execute a paid settlement step

settle · commerce