How do you take an agent from prototype to governed production?

Agent onboarding

In an order where every step is reversible and none of them is write the policy first. Register the agent against a named human with a declared purpose, mint it a credential, change one base URL so its traffic arrives at a governed endpoint, watch what it actually does for long enough to be surprised, write its permissions from what you saw rather than from what you assumed, set hard ceilings before you set any policy, then stage each rule in observation mode and promote them one at a time as separate attributable decisions. About twenty minutes of that is mechanical. Two steps are not, and they are the ones that take the day: deciding who owns this agent and what it is actually for, written as a sentence somebody would defend, and deciding which rule you are willing to have block production traffic at three in the morning. Everything else is plumbing, and treating the plumbing as the project is why so many agent governance programmes have a registry, a dashboard and no rule that has ever refused anything. The last part of onboarding is the part that recurs: a review cadence with a named owner, a retention period somebody decided, and the evidence-integrity settings switched on while the history is still short, because those guarantees only cover what comes after them.
The two steps that are not mechanical
Who owns it and what it is for; and which rule you will let block production
Required to register
Name, owner email, team and declared purpose — nothing else is mandatory
The adoption cost
One base URL and one credential per agent
The order that survives
Register, route, observe, permission, ceilings, then policy
What a readiness check cannot tell youRelease provenance, independent testing, legal approval or your integration matrix
On this page
PROTOTYPE TO PRODUCTION

The order, and why policy is not first

The obvious order is to write the policy first, because policy is the part everyone has an opinion about. It is the wrong order for one practical reason: a rule you cannot measure the effect of is a rule nobody will let you enforce. Every rule that reaches production has to answer whose work does this stop, and the only way to answer that is to have been recording traffic long enough to replay the rule against it.

So the sequence starts with the boring parts. Get the traffic through one point and record it. Register the agent producing it, with a named owner, because every later control is scoped to an agent and an unowned agent is a decision nobody can make. Then write permissions, because deny-by-default keeps working when everything cleverer fails, and because the exercise of writing them tells you what your agent is actually doing. Then ceilings, because a runaway loop is the failure that arrives without anybody misbehaving. Only then policy, staged before it enforces.

Two things run in parallel rather than after. Evidence integrity should be switched on early — not because you need it early, but because both the keyed audit chain and the off-box anchor are forward-looking guarantees, so every month of delay is a month of history that will never be covered by more than a plain hash. And discovery should start before you believe you need it, because its output is the denominator for every coverage claim you will make later.

The honest time estimate for one agent is about an hour, and the shape of that hour is worth knowing: roughly twenty minutes bounded by tooling, and the rest spent on two decisions. Anyone quoting four minutes is quoting the twenty.

Register before you route, and make the purpose a sentence somebody would defend

Four fields are required to create an agent record: a name, an owner email, a team and a declared purpose. The last two are the ones worth arguing about in the meeting. The owner email is the human accountable for a thing that is not a human, lower-cased on write so accountability does not fork on capitalisation. The declared purpose is the field a regulator asks for; it is required rather than optional and it is carried verbatim into every later review, which means a purpose written as does support things will be attested by a named reviewer six months from now and will not help either of you.

Everything else is declared rather than mandatory, and each field earns its place by being read somewhere in the request path. A risk tier, defaulting to limited. Team and tags, which policy scope and kill switches match on — team case-insensitively, tags case-sensitively. A data policy expressed as three independent settings rather than one flag. A routing ceiling, which caps the tier an agent may reach rather than targeting one, so a cheap classifier cannot quietly cost frontier prices. A per-agent switch requiring a named human on every call, off by default. And free-form metadata, which is where an assessment reference belongs so it travels into the review record rather than living only in a console.

The record starts in draft, which is deliberate: a record can exist before anyone has decided to run it. Role references are validated against the authoritative rows inside the writing transaction and an unresolvable one is refused by name, because a dangling role would otherwise reduce the agent to deny-by-default silently — which reads as a policy decision rather than as a typo.

One thing to check on any implementation before you rely on it: whether the record you just created is the record the enforcement point reads on every call, or an inventory maintained beside the runtime. The second kind is updated by whoever remembers while the runtime is updated by whoever ships, and the two diverge from the first week.

Route by changing one thing, then watch before you decide anything

The adoption cost has to be one base URL and one credential, because anything more expensive gets routed around. Point the agent’s client at the governed endpoint for the dialect it already speaks and give it the token you minted. That token is the only copy that will ever exist — the store keeps its digest and a display prefix — so if it is lost, revoke and reissue rather than looking for a recovery path.

Then resist the urge to write rules and watch instead. Every response carries a trace identifier, including refusals, and the trace is an ordered timeline: the request, the policy decisions including matches in observation mode, the redactions by kind, the upstream call with its model, tokens and cost, and the outcome. A week of that will tell you things about your own agent that no design document contains — which tools it actually calls, how often, how large its context really is, and which model ends up serving it.

Two specific things to look for while watching. The model list returned to the agent is filtered to what its roles permit, which is where the permission model becomes visible to a client that knows nothing about your governance layer; if it looks wrong, the grants are wrong. And a refusal is recorded rather than dropped, so an agent probing for something it does not hold shows up as a pattern rather than as an absence.

If you are evaluating offline against a mock provider, know what that proves and what it does not. It proves the plumbing. It fabricates model output, nothing downstream can distinguish that output from a real answer, and a production readiness gate should treat an enabled mock provider as a blocker rather than as a configuration preference.

Permissions from what you saw, then ceilings, then policy

Write the grants as an allowlist of actions the declared purpose requires, and expect the exercise to surface grants nobody can justify — that is the exercise working. Deny by default means an action no permission names is refused and an agent with no roles can do nothing, so the failure mode of getting this wrong is a refusal rather than a silent permission.

Then set ceilings, and set them before you write a single policy, because a runaway loop does not require anybody to misbehave. Four in money — per request, rolling hour, day and month — and three in rate, on requests, tool calls and tokens per minute. The hourly window is the one that catches a loop in minutes rather than at the daily boundary.

One check belongs here specifically and it is the one most likely to be missing: confirm that a model with no price row fails closed for this agent rather than being estimated at zero. A zero estimate passes every ceiling above it, an unmetered estate and an idle one look identical on every spend surface, and the customer finds out from the vendor invoice. Token Observe refuses before egress with a typed error naming the unpriced model, the provider that would have served it and how many further fallbacks are also unpriced — for any agent with a ceiling configured. An agent with no ceiling is explicitly unbudgeted and is unaffected, which is why the count of agents with no ceiling is a number worth watching.

Only now write policy, and stage every rule. Observation mode evaluates the rule exactly as enforcement would, records the match on the trace with the policy, its action and why it matched, then skips it. Let it run against real traffic — a day is better than an hour — then look at what it matched and ask the only question that matters: if this had been enforcing, would the blocked request have been wrong to allow. Promote one rule at a time, and start with the one blocking credentials in prompts, because a leaked credential cannot be un-leaked and, unlike personal data, there is no legitimate reason for one to appear in a prompt at all.

The readiness check, and the questions it explicitly does not answer

A readiness endpoint is worth having and worth reading carefully, because the temptation is to treat a green result as a production certification.

Token Observe reports eight items, each computed from live state rather than from a setup-finished flag, so it goes red again the day somebody revokes the last agent key or rotates a provider credential out of the environment: an active admin account exists; a non-mock provider client is present in the live registry rather than merely enabled as a row; at least one role is defined; at least one agent is active; an active agent holds an unrevoked, unexpired key; at least one enabled policy is in enforcing mode; the recorder has recorded at least one request; and the hash chain verifies end to end.

A stricter technical state sits above those eight and adds the things a bounded evaluation actually needs: a usable provider client, a keyed audit chain, an active anchor signer with a configured sink whose delivery cursor is exactly at the newest local anchor — behind means undelivered and ahead signals a restored or deleted local suffix — an explicit production boot posture with bounded proxy trust, explicit webhook destinations, and the supported single-process topology. The mock provider is a blocker there, and so is an evaluation-only database backend.

And then the part that is easy to skip and is the reason to read this section. That endpoint states, in every response, that it cannot evaluate the things that actually gate a production release: release provenance, an independent security assessment, your specific integration matrix, workload-shaped soak and restore evidence, legal and support approval, or a production reference. A green technical result is a statement about locally observable configuration and nothing else, and any product whose readiness check does not say so is inviting you to read it as more.

Computed from live state
Every item is derived rather than flagged, so revoking the last key or rotating a credential out of the environment turns it red again the same day.
Registered is not usable
A provider row that is enabled but whose client construction failed is red, because a row in a table is not a provider the request path can reach.
The mock provider is a blocker
It serves invented model output and nothing downstream can tell. Useful offline, disqualifying in production.
What it cannot evaluate
Release provenance, independent testing, your integration matrix, restore evidence, legal approval, a production reference. Stated in every response rather than in a footnote.

The part of onboarding that recurs

Three things get decided once during onboarding and then have to be maintained, and skipping them is how a governed agent quietly becomes an ungoverned one that is still in the registry.

A review cadence with a named owner. A recertification binds a named reviewer to a digest over the exact governance-bearing configuration — including a hash over each referenced role’s normalised permissions rather than merely its identifier, so widening a role marks every affected review stale immediately without rewriting what was attested. The honest limit belongs beside it: an overdue or stale review never suspends the agent, and there is no notification scheduler, so the cadence is a process you run rather than one the software runs for you.

A retention period somebody chose. The default is unset, and unset means keep forever, which over-satisfies a minimum-retention duty and satisfies no storage-limitation duty at all. Decide the period, and then write down what it does not cover — approvals, discovery findings, webhook delivery records and identity snapshots each sit outside it — before anybody quotes a number to a data protection officer.

The evidence-integrity settings, switched on while the history is short. Keying the audit digests requires a key injected from a secret manager your database administrators cannot read and a two-boot ceremony; anchoring requires a signing key held in a key management service and a destination somebody else controls. Both cover only what comes after them, and there is one consequence worth planning for rather than discovering: reviews recorded before the first keyed checkpoint become invalid and have to be repeated, because promoting a legacy record without verifying its descendant path would let a database writer rewrite both the record and the thing referencing it.

Finally, decide the operational answers before traffic rather than during an incident: who may engage and release the kill switch, who owns the backup, who has authority to restore, and what happens to agent traffic while the gateway is unavailable. A control that refuses when it cannot decide is a dependency of everything behind it, and that sentence is much easier to agree with in a design review than at three in the morning.

in practice

How to put agent onboarding into practice

  1. 01

    Register the agent against a named human

    Name, owner email, team and a declared purpose written as a sentence somebody would defend six months from now. Start it in draft; a record can exist before anyone decides to run it.
  2. 02

    Mint one credential and treat it as the only copy

    The plaintext is returned once and stored as a digest. Losing it means revoke and reissue, which is one write and takes effect on the next authentication attempt.
  3. 03

    Change one base URL

    Point the agent’s existing client at the governed endpoint for the dialect it already speaks. Anything more expensive than one URL and one credential gets routed around.
  4. 04

    Watch for a week before deciding anything

    Read the traces: which tools it really calls, how large the context really is, which model actually serves it, and what it tries that gets refused. Design documents are not evidence about your own agent.
  5. 05

    Write permissions from what you saw

    An allowlist of actions the declared purpose requires, denying by default everywhere else. Expect to find grants nobody can justify; removing them is the highest-value hour in the process.
  6. 06

    Set ceilings and confirm an unpriced model fails closed

    Per request, hour, day and month, plus per-minute request, tool-call and token limits. Then check that a model with no price refuses rather than estimating zero, because a zero estimate disarms every ceiling above it.
  7. 07

    Stage every rule, then promote one at a time

    Observation mode over real traffic, read what it would have stopped, and promote as a separate audited act. Start with credentials in prompts, because a leaked credential cannot be un-leaked.
  8. 08

    Name the review owner, the retention period and the key custody

    A cadence with a person against it, a period somebody decided along with what it does not cover, and the audit key and anchor configured while the history is short.

How long does it really take to govern one agent?

About an hour, of which roughly twenty minutes is mechanical and bounded by tooling — installing, booting, registering, minting a key, changing a base URL and watching the first trace. The rest is two decisions that deserve the time: who owns this agent and what it is actually for, written as a sentence somebody would defend at a review, and which rule you are willing to have block production traffic at three in the morning. The second is why the honest answer is an hour rather than four minutes, and it does not get shorter with practice because it is a judgement rather than a task.

Why write permissions after routing rather than before?

Because a week of recorded traffic tells you what the agent actually does, and the design document tells you what somebody intended it to do. Writing grants from the second produces a permission set that is simultaneously too wide, because it includes things nobody removed, and too narrow, because it misses a tool the framework calls that nobody documented. Routing first also costs nothing to reverse: the agent record can sit in draft, deny-by-default means an unlisted action is refused rather than silently permitted, and every refusal is recorded so the gaps in the grant list are visible rather than inferred.

What should the first enforcing rule be?

The one blocking credentials in prompts. A leaked credential cannot be un-leaked, and unlike personal data there is no legitimate reason for one to appear in a prompt at all, so the false-positive conversation is short. Promote it as a separate audited act after it has run in observation mode over real traffic, and remember that secret kinds are masked irreversibly whatever a rule’s mode says, because a reversible placeholder for a credential is a credential. Then promote the next rule on its own rather than promoting a batch, so an unexpected effect has one cause.

What does a green readiness check actually mean?

That a set of locally observable configuration checks currently pass, computed from live state rather than from a setup flag — so it goes red again the day somebody revokes the last key. It does not mean the deployment is production-ready, and a good implementation says so in every response. Token Observe’s explicitly states that it cannot evaluate release provenance, an independent security assessment, your integration matrix, workload-shaped soak and restore evidence, legal and support approval, or a production reference. Treat it as a pre-flight checklist rather than as a certificate.

When should the audit key and anchoring be switched on?

During onboarding, while the history is short, because both guarantees are forward-looking. Keyed digests cover entries written after the key was introduced; earlier entries are covered only by the checkpoint over the head they reached. An anchor attests the head as it stood when the anchor was made and says nothing about whether the history beneath it was honest. There is also one consequence to plan for rather than discover: reviews recorded before the first keyed checkpoint become invalid and have to be repeated, because promoting a legacy record without verifying its descendant path would let a database writer rewrite both the record and the thing referencing it.

Ask about this guide
Ask anything about the subject. These guides are written to be useful whether or not you ever buy anything, and this answers in the same spirit.

Prefer to ask a person? Write to us →

get in touch

Bring us the question this guide did not answer.

Write to hello@tenhaw.com with what your agents do, which providers they call and what would have to be true for you to put something in front of them. James Rooney replies. You will get a straight answer about whether Token Observe fits, including when it does not.

no form · no qualification step · no sales desk · the other three ways in