ISETAgentic Commerce
Agentic commerce · mandated authority

Whose agent is this — and within what limits? One call.

The question agentic commerce cannot answer is the question registers exist to answer. On the corridor, an AI agent never owns authority: it exercises a principal's recorded mandate — scoped, limited, expiring, revocable. Every event the agent triggers carries the mandate with it. Out-of-mandate actions are refused at the edge, not detected afterward. Responsibility, by construction.

The open question · and the registry's answer

The industry is asking. The register already answers.

Banks and platforms are convening panels on who is responsible when an agent transacts — because payment systems can only detect anomalies after the fact. Proof systems prevent them before.

The open question

"Who is responsible when an agent makes a payment?"

Payment rails authenticate a user, then watch what happens. When an assistant initiates the transfer, the rail can say only that "the user authorized it" — it cannot show what the agent was authorized to do, up to how much, until when. Liability becomes a dispute between guesses.

The registry's answer

Authority is a record. Limits are a record. Acts carry their mandate.

A mandate is registered before any act: principal, agent key, scope, limits, expiry. Every event the agent triggers embeds the mandate reference and is signed. In-mandate, the principal is bound. Out-of-mandate, the register refuses. Dispute? One call returns the whole chain.

The mandate

An agent's authority is an object on the register.

Registered by the principal before the agent acts — signed like every record, publicly checkable like every record, revoked like every record.

Anatomy

PrincipalA verified issuer on the registry — a business, not a wallet
Agent keyThe credential the agent signs with — bound to exactly one principal
ScopeWhich instrument classes and which actions — issue, pledge, transfer, payment-request
LimitsMaximum value per instrument, per period — the ceiling is in the record, not in a prompt
CounterpartiesOptional whitelist — the agent may act only toward named, verified parties
ExpiryAuthority dies on schedule even if nobody remembers to revoke it
StatusActive · revoked (with the revocation timestamp) — public at one call

Illustrative record

{
  "mandate":    "MDT-2026-0042",
  "principal":  "Manila Trade Inc",
  "verified":   true,
  "agent_key":  "ak_9f14…c2",
  "scope":      ["eCI issue", "ePN pledge"],
  "limit":      "PHP 250,000 / instrument",
  "counterparties": ["3 verified buyers"],
  "expires":    "2026-12-31",
  "status":     "active"
}

Every lifecycle event written under this mandate carries mandate_ref: MDT-2026-0042 — the act and its authority are inseparable.

Enforcement · at the edge

Three outcomes. No exceptions.

The same edge that refuses unlawful endorsements refuses out-of-mandate acts. The agent is not trusted and then monitored — it is structurally confined.

In mandate → bound

The principal is bound

The act proceeds, signed, carrying mandate_ref. Like an officer's signature, the principal owns what their mandated agent did — and the record proves the mandate covered it.

At a limit → priced

Over the ceiling, refused or renegotiated

An act beyond the value limit returns mandate_exceeded. The principal can raise the limit by registering a new mandate — the old one and its ceiling remain on the record forever.

Out of mandate → refused

The rogue act was never possible

Wrong class, wrong counterparty, expired, or revoked: the edge returns 403 mandate_revoked / mandate_expired / out_of_scope before the engine sees it. Detection is for systems without registers.

REVOCATION IS CONTAINMENT — A compromised agent is not an incident to manage; it is a timestamp to write. Revoke the mandate and authority dies at that second — every later act is provably post-revocation, attributed to the actor who tried it, not the principal. Breach containment, answered cryptographically.
Who is responsible · mapped

Payment liability stays on the rails. Transaction liability becomes proof.

The registry is non-custodial — it never holds or moves funds, so it sits outside the payment-liability zone entirely. What it owns is the half nobody else can prove.

QuestionWhere it is answeredAnswer
Who bears the payment?The bank railsUnchanged — principal, bank, and platform, under their own terms. The registry holds no funds and takes no part in the money movement.
Was the agent authorized for this act?The mandate recordYes/no, to the second: scope, limits, expiry, status — public, signed, revocable.
Was this event within the mandate?The event itselfEvery act embeds its mandate reference and is signed. In-mandate → principal bound. Out-of-mandate → refused, never written.
Who acted after revocation?The revocation timestampAnyone who tried is provably not the principal's agent anymore — attribution without ambiguity.
Is this agent trustworthy over time?The rating layerAgents build their own signed performance records — earned, bounded, recent — the same evidence discipline as counterparties.
Status

Reading agents: live. Acting agents: specified.

The trust layer agents need for reading the registry is in production today. The mandate layer for acting is published as Spec v0.9 — the enforcement machinery it builds on is already the registry's core.

Live today

What an agent can do right now

  • Verify any record — public, keyless GET, CORS-enabled: GET /api/etr/verify/{ref}
  • Read as tools — MCP console (JSON-RPC 2.0), scoped read keys, twelve sample references
  • Discover the registry — machine-readable surfaces: /llms.txt, JSON-LD schemas, capabilities manifest
  • Learn the rules — the full read-only sandbox, no signup, including the refusal gallery
  • Pull evidence packs — GET /api/etr/evidence/{ref}: instrument lifecycle, protection interests, orders, and mandates in one call
Spec v0.9.1 — commerce scope enforcing

What mandates add — enforcing on the commerce scope

  • Mandate records — POST /api/mandates · public read · revoke with timestamp
  • Edge enforcement — scope, limit, counterparty, expiry checks on every agent write: 403 mandate_*
  • Event binding — mandate_ref embedded in every lifecycle event the agent triggers
  • Metrics — GET /api/metrics: the chamber report figures, computed per party

The build order is small by design: officer authority, refusal at the edge, signing, and the rating layer already run. A mandate is officer authority, scoped and delegated.

For agent builders

Provider-agnostic, by architecture.

Any agent, from any maker, can transact on the corridor — because trust is answered by the register, not by the agent's brand. Start reading today; the mandate spec is public and stable.

Step 1 · Read

Point your agent at the open surface

/llms.txt for orientation, the verify endpoint for checks, the capabilities manifest for discovery. No account, no key.

Step 2 · Practice

Exercise the rules in the sandbox

The MCP console and REST console expose the real enforcement surface read-only — including the refusal gallery. Your agent should learn what the register refuses.

Step 3 · Act (soon)

Register a mandate, act inside it

Live on the commerce scope today: register a mandate, then place orders with your agent key — every order carries its mandate reference — the beginning of an attributable, provable trading history.

POSTURE — ISET is not an agent operator, not a wallet, and not a payment rail. Agents remain someone else's product; the registry is the proof layer they cannot misrepresent. Settlement stays on the parties' own bank rails, always.