Agentry
Product overview
Mandate is the company. Agentry is the product: the API that platforms and businesses integrate.
Mandate is a UK mandate design company. We design how a business hands authority to a software agent, and how anyone that agent deals with can check it for themselves. The binding says which agent is acting, for which business, within what scope and for how long, and that a person there confirmed it. The mandate says what money, if any, may move under it. The record ties what the agent did through Agentry back to that business. Today Agentry keeps the binding and the record, in sandbox. It issues no record a counterparty can act on yet, and it holds no mandate. We design the mandate. We do not execute it today.
This page says what Agentry is, what is available today, what it is not, and what comes later. Anything that comes later is described as later.
What Agentry is
Every business will have an agent operating on its behalf. Agentry exists to make that safe, by keeping each business's own record of which agents act for it, what a person there allowed each to do, and what each did through Agentry.
Mandate is the compliance layer for agentic commerce: the control and evidence layer an agent's payment needs before any regulated firm will execute it.
AI agents can already negotiate terms and decide what to pay. They cannot hold a licence, produce a consent record that satisfies UK payment law, verify who they are paying, or leave a receipt a regulator will accept. The platforms racing to build agent commerce, from Google and Stripe to Cloudflare, standardise the messages and settle what regulation does not touch, then stop, by design. And the firms that can execute a regulated payment, the UK's authorised payment initiation providers, have none of the controls an autonomous payer needs. Mandate's product, Agentry, is being built to close that gap: a consent record scoped, capped, expiring and revocable by design, counterparties verified before a payment order exists, and an evidence chain built to the standard a regulated firm requires before it will accept an agent's instruction. What is available today is the trust layer, which verifies businesses, registers them, and issues portable proof, and which moves no money. Execution under the mandate follows Mandate's own FCA authorisation, which we intend to apply for and do not hold.
Who it is for
Agentry is the API that platforms and businesses integrate. Today that means a UK limited company, or an agent acting for it, having the company checked and taking away a signed record of what was checked. The company can then record the agents that act for it, and a person at the company confirms what each may do.
UK limited companies only. Sole traders are not supported yet.
Your agent already runs somewhere: in an AI assistant, an agent platform, or software you run yourself. Agentry connects to it there, through that platform's own way of adding tools. Today that is any MCP client that lets you set an API key; the platform connectors follow.
Today: the Trust API, in sandbox
Agentry's Trust API verifies a UK limited company, registers it, and issues a portable, signed record of what was verified. It moves no money.
The Trust API is in sandbox. Every key it issues is a sandbox key, and nothing in it issues a live one. It moves no money and makes no regulatory claim: nothing in it initiates, holds, receives or settles a payment, and no tool on it can.
- Register the business. A business registers itself with its Companies House number, a contact email and, optionally, a contact name. That binds the key to the company. One business per key.
- Run the two checks. Agentry checks the company against the Companies House register, and the person controlling the account completes an identity check on the identity provider's hosted page. No tool can complete that step.
- Take a signed proof. When both checks hold, the business can read its own status and take away a signed proof. A proof issued today is a sandbox proof: it says so in its signed text and is not evidence about the company for anyone to rely on. A live proof, when there is one, is what a counterparty checks offline against Agentry's published key, without contacting us.
- Record the agents that act for it. Agentry records the agents that act for the company, and asks a person at the company to confirm what each may do, from a fixed list of four words, until a date. The confirmation link goes to the account's contact address and is never returned to the caller, so an agent cannot confirm itself.
- Give each agent its own credential. Each confirmed agent is issued its own credential, which stops working the moment the confirmation behind it ends. An agent can also record a public key it already controls, once it has signed a one-time challenge with it. Agentry keeps the key's thumbprint and never the key. A signed record an agent hands a counterparty, saying which verified company stands behind it, cannot be issued on any deployment today, because the officer match behind it does not run yet.
Status reads are self-only: a caller sees its own business and no other. There is no lookup by company number and no directory.
The 14 tools
A Trust API key lists exactly these 14 tools and can call nothing else. No tool on it initiates, holds, receives or settles a payment.
The business
- register_business
- registers a business and binds your key to it, with its Companies House number, a contact email and, optionally, a contact name. One business per key.
- check_company
- runs the Companies House register check for that business. It takes no company number, because the company is the one your key is bound to.
- get_my_verification_status
- reads your own business's status and, once both checks hold, returns a freshly signed proof.
- delete_my_business
- deletes the account record and revokes every key issued to the business, including the one that made the call.
Its agents
- register_agent
- records a software agent that belongs to the business. On its own it grants the agent nothing.
- request_agent_binding
- asks a person at the business to confirm what one of its agents may do on the business's behalf. The link goes to the account contact address and is never returned to the caller, so an agent cannot confirm itself through Agentry, though anything that can read that mailbox can open the link.
- resend_agent_binding_confirmation
- sends the confirmation email again for a request still waiting for a person. The links in any earlier email stop working, and the deadline does not move.
- list_my_agents
- lists the business's own agents and where each one's confirmation stands.
- revoke_agent_binding
- ends what the business confirmed about one of its agents, at once. A person can also end it through a link, with no key at all.
The identities its agents hold
- request_agent_identity_challenge
- starts recording an identity an agent already holds elsewhere, by returning a one-time challenge. Nothing is recorded until the agent returns it signed.
- confirm_agent_identity_link
- completes that recording. Agentry checks the signature against the key the identity names and keeps the key's thumbprint, never the key.
- revoke_agent_identity_link
- stops including one of an agent's recorded identities in what that agent presents.
Its own record of what they did
- list_agent_activity
- lists, newest first, what Agentry has recorded about the business's own agents: the events on their records and the signed records issued to them, with the confirmation each was under and, where it was recorded, the key or emailed link it came through. It shows nothing about any other business.
- get_my_audit_pack
- exports the business's own audit pack for a period: what Agentry has recorded about the business and its agents, and a manifest, checkable by anyone who holds it. It shows nothing about any other business.
The transport is MCP over HTTP. The tools are native MCP tools, so any MCP client or agent framework that lets you set a bearer key can discover and call them, and with no agent at all a call is a JSON-RPC body sent with curl. Clients that require OAuth rather than a static key cannot connect yet; the platform connectors follow.
Conventions
- Scope. Declared per tool. The gateway filters what a caller can see at discovery and rechecks it at invocation.
- Idempotency. Every call that changes something carries an idempotency key you choose. Repeat a call with the same key to retry safely.
- One shape. Every response field a tool can return is present in every response from that tool. A field that does not apply is null, never absent.
- Identity. A presented key is looked up, never believed. A confirmed agent's own credential stops working the moment the confirmation behind it ends.
The agent signing kit
Your agent's own signing key, kept in a key store and never returned by this library
The agent signing kit for Agentry is a small library an AI agent's operator installs so that the agent has its own signing key, kept in a key store and never returned by this library. It does four things: creates a key inside a key store; gives you the public key and its RFC 7638 thumbprint; answers an Agentry identity challenge, so Agentry can record that the agent controls the key; and signs HTTP requests as RFC 9421 message signatures in the Web Bot Auth format, so a website or API that checks Web Bot Auth signatures can tell which key directory's key signed the request.
It never returns a private key, and it has no function that signs arbitrary bytes. It moves no money. It is for agents you run yourself: an assistant hosted by a platform signs with the platform's key, which no single business can claim. You publish the key directory on an https origin you control; Agentry hosts none.
It is not yet published. It is written to be released under an open source licence, which has not yet been chosen; when it is published, this page will link it.
import { KMSClient } from "@aws-sdk/client-kms";
import { createKey } from "<package>";
import { awsKmsBackend } from "<package>/aws-kms";
const backend = awsKmsBackend({ client: new KMSClient({ region: "eu-west-2" }) });
const created = await createKey({ backend }); // ES256
if (!created.ok) throw new Error(created.error.message);
const key = created.value;
key.ref; // the KMS key ARN: store this to reopen the key later
key.publicJwk; // { kty: "EC", crv: "P-256", x, y }
key.thumbprint(); // 43 characters, base64url
// request_agent_identity_challenge returned a string beginning agentry-identity-v1.
const answer = await key.signChallenge(challenge);
if (!answer.ok) throw new Error(answer.error.message);
// confirm_agent_identity_link takes answer.value.challenge, .publicKey and .signature- Where the key lives. In this version, inside AWS KMS, which has no operation that returns the private half of a key it generated. A hardware backend is defined and not built. A file backend exists for development only and refuses to run outside it.
- Two key types. ES256 for Agentry identity challenges, the default. Ed25519 for Web Bot Auth. If a backend cannot hold the type natively, the kit refuses rather than making a software key instead.
- What a signature shows. It does not make an agent trusted or verified. A valid signature shows which key signed a request and which key directory published that key. It does not show who the agent acts for, or whether to deal with it. Linking a key records with Agentry that your agent controls it, and nothing more.
How a proof works, and how to check one
A proof is a compact JWS signed with ES256 and issued under the standard trust_v1. It carries everything needed to check it apart from Agentry's public key set, published at /.well-known/agentry-trust-jwks, which a reader fetches once and pins. Checking a proof needs no Agentry account and no key, and once the key set is pinned, no call to us.
What a proof states, in its own signed text:
This record states that, on the dates given, the company named was present on the Companies House register and its register status passed the issuer's check, and that the person controlling the Agentry account for this company passed an identity check. It does not establish that those are the same person, or that the person is an officer of the company. The checks were performed by the issuer for the subject's own use, are valid only until the expiry date carried in this record, and are not refreshed after issue. This record is:
- not a statement about creditworthiness or solvency (no financial information was collected)
- not an audit
- not a guarantee
- not evidence the issuer is authorised or regulated
- not customer due diligence under MLR 2017
- not confirmation that the person who passed the identity check is an officer of the company
- not a current statement
- not transferable
- This proof carries an `env` claim stating the environment that issued it. Where `env` is `sandbox` this is a test artefact: the checks it names may not have been performed against any register or any person, and it is not evidence of anything about the company it names.
{
"iss": "https://<agentry-host>",
"sub": "0b8f7d2c-4a19-4d64-9a3e-5b1c7e02f8aa",
"jti": "d1a53a0e-4d0f-4ad5-9f8e-91a2b6c7d3f4",
"iat": 1758100262,
"nbf": 1758100262,
"exp": 1758705062,
"standard": "trust_v1",
"env": "sandbox",
"company": {
"number": "00000000",
"name": "EXAMPLE TRADING LTD"
},
"status": "verified",
"checks": [
{
"name": "company_register",
"result": "passed",
"asAt": "2026-09-17T09:22:41.006Z",
"source": "sandbox_fixture",
"evidenceBasis": "performed_by_issuer"
},
{
"name": "account_controller_identity",
"result": "passed",
"asAt": "2026-09-17T09:31:18.442Z",
"source": "sandbox_fixture",
"evidenceBasis": "performed_by_issuer"
}
],
"limits": {
"statement": "…",
"isNot": [
"…"
],
"statementUrl": "https://<agentry-host>/trust/standards/trust_v1",
"issuedFor": "subject_own_use"
},
"verify": {
"jwksUrl": "https://<agentry-host>/.well-known/agentry-sandbox-trust-jwks",
"verifierUrl": "https://<agentry-host>/trust/verify-proof"
}
}A proof is not refreshed after issue, and there is no revocation service: it verifies until it expires and is neither refreshed nor revoked before then. A proof issued in the sandbox says that it is one. It carries the signed typ agentry-sandbox-proof+jwt where a live proof carries agentry-trust-proof+jwt, it expires 7 days after issue, and the shipped verifier refuses it by default; a reader who explicitly opts in to reading sandbox proofs gets it back as not valid for reliance, never as valid.
- Read the trust_v1 standard: what a proof issued under it states, how it is signed, and how long it lasts.
- Read how to check a proof: offline, without asking the issuer, and what each of the three results means.
What Agentry is not today
- Not a payment service. Agentry does not move, hold, initiate or receive money, and no live money has moved through anything Mandate has built.
- Not enforcement. Nothing in the Trust API can refuse a payment, because nothing in it touches a payment.
- No FCA permissions. Mandate holds no FCA permissions and claims none. The Trust API moves no money.
- Not a reliance service. A proof is issued to the business named in it, for that business to present. Nobody can look a business up through Agentry: third-party lookups are a later phase, and they need reliance terms that have not been published.
- Not a credit check. Agentry holds no financial information about any third party. It is identity and registration.
Do not present a sandbox proof to a third party, and do not build a flow that shows one to anyone. A proof is built to travel without us. A sandbox proof says in its signed text that it is a test artefact, but that protects only a reader who reads it.
What comes later
A mandate names one supplier, a maximum amount, one or more periodic limits and an expiry, and the payer can revoke it. Refusing a payment that falls outside the mandate happens at execution, and execution follows authorisation. Unless and until that authorisation is granted, Agentry executes no payment.
Mandate is never in the flow of funds and holds no balance for anyone, by design and by scope: payment initiation moves money between the payer's own account and the payee's.
Where a third party executed the payment and told us about it, the receipt says so in its own text: the evidence is attested, not witnessed.
Looking up a business that has not handed you a proof is a later phase, and the platform connectors follow. None of this carries a date, and none is given here.
Documentation
The developer documentation is provided to design partners. It covers registration and the two checks, the agents that act for a business and what a person there confirms about them, proofs and how a counterparty checks one offline, the business's own record of what its agents did, errors, the sandbox and deletion. Every request and response in it is taken from the code that serves it, and most of it is held there by a test.
If you hold an access token, open it here.
Access
The Trust API is not open for sign-up. It is in sandbox ahead of launch, and keys are not available to the public.
This page takes no identifier, reads no record and shows no personal data. Agentry records who a business is. It does not move, hold or initiate money.
Mandate and Agentry are trading names of Timesthree.io Ltd, registered in England and Wales, company number 15046379. Registered office 20 Gracechurch Street, London EC3V 0BG.