Should AI governance run in my own network?

Self-hosted or hosted governance

If the control is inline — if it refuses calls rather than reporting on them — then it runs where your agents run, because everything an inline control touches is the thing you were trying to protect. It sees every prompt and every tool argument before anyone has decided whether they were allowed to leave, it holds the credentials for every model provider in the estate in one process, and it produces the record you would use to establish what happened. Handing all three to a third party to solve a governance problem is a defensible decision, but it is a decision about adding a processor to the most sensitive path you have, and it should be made explicitly rather than by default. The three questions that settle it are: who holds the payloads, who can rewrite the evidence, and what happens when the control plane is unavailable. Self-hosting answers the first two in your favour and makes the third your problem, because a fail-closed control in the request path is a dependency of every agent you run. The costs are real and worth naming: you run the backups, the restore drills, the key ceremonies, the upgrades and the TLS, and you accept whatever availability envelope the software actually has rather than a vendor’s uptime commitment.
What an inline control holds
Prompts, tool arguments, every provider key, and the decision record
The three questions
Who holds payloads, who can rewrite evidence, what happens when it is down
Verifying a no-telemetry claim
Enumerate the outbound call sites and the hard-coded hosts yourself
What self-hosting hands you
Backups, restore drills, key ceremonies, TLS, upgrades and the availability envelope
What self-hosting does not settleSupport access, incident handling and evaluation terms are still a legal question
On this page
WHERE IT RUNS

Three questions, and how each one lands

The first question is who holds the payloads. An inline governance layer reads every prompt, every tool argument and every tool result, because that is what it means to decide whether they may proceed. If it runs somewhere you do not control, a copy of the most sensitive traffic in your organisation crosses a boundary before any control has decided whether it should have. That is not automatically wrong — plenty of organisations put customer data through hosted services deliberately and with a contract behind it — but it is a decision to make with your data protection officer in the room, not one to arrive at because a hosted deployment was quicker.

The second is who can rewrite the evidence. Governance evidence exists to answer questions about your organisation’s behaviour, which means the interesting adversary is an insider. If the record lives with the vendor, you have moved the threat from your administrators to theirs and gained a party who can be compelled, acquired or breached independently of you. If it lives with you, the record is protected against the vendor and exposed to your own database administrators, which is exactly the threat that keyed digests and off-box anchoring exist to address. Neither arrangement removes the problem; they relocate it, and the honest question is which relocation you can actually manage.

The third is what happens when the control plane is unavailable, and it is the one that catches teams out. A control that refuses when it cannot decide is a dependency of every agent that routes through it. Self-hosting makes that dependency yours to engineer, which is better than it being someone else’s to engineer without telling you — but only if you actually engineer it. The concrete artefact is a written answer to what happens when the fail-closed gateway is down: agents stop, or a named person makes a decision under a documented procedure. Token Observe’s own design-partner gate lists exactly that as an item that must have an owner before traffic flows.

Notice that none of the three is about trust in the abstract. They are about custody, adversary and dependency, and each has a checkable answer.

A fail-closed control is a dependency, and that cuts both ways

The property that makes a governance layer worth having — it refuses — is the same property that makes it an availability risk. Everything else in this comparison is downstream of that trade.

There is a temptation to soften it: fail open when the control cannot decide, so that an outage in governance is not an outage in the business. Resist it, and be explicit about why. A control that fails open is a control that an attacker can turn off by making it unavailable, and it is also a control that is off during exactly the incident it was bought for. Token Observe fails closed on every governance-bearing failure, including refusing governed requests with a typed unavailable error when it has detected corruption in its own evidence chain, and latching that state until a restart — because appending to a chain it has just found unsafe would be worse than refusing.

What you can do instead is bound the blast radius of the dependency. Keep the process small and its dependency list short — Token Observe’s governance domain has no runtime dependencies at all and the server has four, which is a supply-chain argument as much as an availability one. Put the deployment behind your own TLS terminator with a read timeout longer than your slowest model response and response buffering switched off, because streaming breaks under a buffering proxy. Keep the control plane off the internet. Decide, in advance and in writing, who may engage and release the kill switch and what the fallback is if the gateway itself is gone.

And be realistic about the envelope you are inheriting. Token Observe is one process with one write path and its own database file. A PostgreSQL adapter exists behind the store ports as an evaluation alternative with dual-backend testing for store and concurrency invariants, and it is explicitly not a supported high-availability topology, a multi-replica claim or a point-in-time recovery result. Kubernetes and Terraform deployment material exists and deliberately deploys one process rather than a replica set. If your requirement is an inline control with a replicated write path, that requirement is not met by this shape and no amount of self-hosting changes it.

Four shapes, and what each one actually costs

Single node is the baseline: one container, a mounted volume, a reverse proxy in front. It suits one control plane serving a whole organisation at the scale this design targets, and the cost is that the write path is one process by design.

Hybrid inside your own cloud network is the same artefact with different egress. Nothing about the image changes — only where it runs and which destinations it is allowed to reach — and payloads leave only to the model providers you explicitly enabled. The proxy in front has real requirements rather than nominal ones: it terminates TLS, it must not buffer responses or streaming breaks, it preserves the authorisation headers, it is the only thing setting the forwarded-for headers, and its read timeout is at least as long as your longest model response.

Air-gapped works, with two things to plan. Prices load from a shipped catalogue at boot so an install is metered from the first request without reaching anything, and the refresh path — the one optional call to a public catalogue — simply never runs. Providers point at internal endpoints instead: a self-hosted inference server, a cloud model service through a private endpoint. Building the image from source still needs the base image and package registries, so mirror those or import a verified release image before disconnecting.

A platform-as-a-service deployment is single node with someone else’s volume and edge, and it carries defects configuration cannot fix. Token Observe names three for that shape: an unauthenticated metrics endpoint on a public hostname, deploy-time-only health checks that make its readiness gate inert, and platform volume snapshots that bypass its restore tooling. There is also a trap worth knowing before you meet it, which is that the audit key ceremonies are designed to boot deliberately unready for their entire life, so a platform that gates deploys on a readiness endpoint will mark them failed and roll them back.

Across all four, two destinations are worth configuring regardless of shape: an authenticated receiver for signed audit anchors, so the evidence about your chain lives somewhere other than the database it attests, and encrypted off-box backups. Both are the same argument — a record held only by the party under examination is worth less than a copy somebody else is holding.

Single node
One process, one volume, one write path. Publish the listener on loopback and put TLS in front; the metrics endpoint is unauthenticated by convention and carries agent identifiers and month-to-date spend.
Inside your own network
Same artefact, different egress. The proxy must not buffer responses, must preserve the authorisation headers, and must allow a read timeout longer than your slowest model call.
Air-gapped
Prices load at boot so metering works offline; providers point at internal endpoints. Building from source still needs registry access, so import a verified image before disconnecting.
Managed platform
Three defects configuration cannot fix, and a readiness gate that will roll back the key ceremonies unless you switch the health check for those deploys.

How to verify a no-telemetry claim rather than accepting it

Any self-hosted vendor will tell you their product sends them nothing. The useful version of that claim is one you can check in an afternoon, and asking for it is a reasonable procurement request regardless of which vendor you are talking to.

Enumerate the outbound call sites in the source and ask where each one gets its destination. Token Observe’s are the provider clients, the embeddings path, the tool-server client, the webhook publisher, the identity-provider client, the anchor sink publisher and one price catalogue — every one taking its URL from operator-supplied configuration except the catalogue, which is a public host and only runs when an administrator invokes it. Then enumerate the hard-coded hosts, and read what is left over: in this case, provider defaults, a region-derived cloud endpoint, the catalogue, a local demo tool server, two schema identifiers embedded as literal strings in a chat-platform card payload that are sent to your receiver and never fetched, and one attribution header naming the project repository, which goes to a model provider rather than to the vendor.

Then stop reading and watch it. Run the deployment with egress allowed only to your providers and confirm nothing is blocked. A product that cannot survive that test has a destination it did not tell you about; a product that can has demonstrated the claim rather than asserted it.

Two further checks are cheap and worth doing. Look at the runtime dependency count, because every dependency is supply-chain surface in something you will deploy air-gapped — Token Observe’s governance domain has none and its server has four. And read the exceptions the vendor states about their own claim: Token Observe records that a primitive for sending email exists in its event publisher and is never configured, precisely because a reviewer auditing the source will find it, and presence of a primitive is not presence of a feature. A vendor volunteering the awkward finding before you make it is worth more than a clean assertion.

What self-hosting hands you, stated as work rather than as a feature

Backups and a restore drill you have actually run. A retained full snapshot is not point-in-time recovery, and the obvious success criterion — the process starts — is not the criterion that matters. What matters is that the restored evidence chain verifies against a head you recorded outside the system, because a restore that lost its tail also lost the attestation of that tail and will verify clean against its own stored state.

Key custody, and two ceremonies. Keying the audit digests means injecting a key from a secret manager your database administrators cannot read, and Token Observe requires a two-boot ceremony with an external one-shot flag to enable it and another to rotate it, precisely so that database rows cannot silently invent an epoch. Signing anchors means holding an Ed25519 private key in a key management service and distributing the public half out of band. Both are forward-looking guarantees, so the cost of postponing them is a permanently weaker prefix of history.

Retention as a decision. Token Observe’s trace retention is unset by default and unset means keep forever, which over-satisfies a minimum-retention duty and satisfies no storage-limitation duty at all. Somebody has to choose a period, and somebody with a legal qualification has to say whether the obligation applies. That is a decision self-hosting hands you along with the disk it fills.

And the residual risks, accepted in writing rather than assumed away. Token Observe’s own commercial-readiness document lists what a customer would be accepting: a single-node deployment on an embedded database, no vendor-operated service level, no independent certification, and an endpoint-seat surface published as preview. It also states that its licence is a template drafted by the engineering team pending review by counsel, that no independent penetration test has been carried out, and that it holds no SOC 2 report and no ISO certification. Those are the sentences to look for in any vendor’s material, and their absence is more informative than their content.

in practice

How to put self-hosted or hosted governance into practice

  1. 01

    Decide the custody question before the feature comparison

    Write down who will hold prompts and tool arguments, who will hold the provider credentials, and who will hold the decision record. If any answer is a third party, that is a processor decision and belongs with your data protection officer.
  2. 02

    Write the unavailability answer down

    A fail-closed control in the request path stops agents when it stops. Name the person who decides, the procedure they follow, and whether the answer is that work halts. Do this before traffic, not during the first outage.
  3. 03

    Put a proxy in front that meets the real requirements

    TLS terminated, response buffering off or streaming breaks, authorisation headers preserved, forwarded headers set by the proxy alone, and a read timeout longer than your slowest model response.
  4. 04

    Verify the egress claim rather than accepting it

    Enumerate the outbound call sites and hard-coded hosts, then run the deployment with egress allowed only to your own providers and confirm nothing is blocked.
  5. 05

    Narrow the two allowlists on day one

    Which hosts a provider may be registered against, and which environment-variable prefixes a credential may come from. Neither list may be empty, and narrowing them is what stops a registry write becoming a read of every secret in the process.
  6. 06

    Run the key ceremonies while the history is short

    Key the audit digests from a secret manager your database administrators cannot read, then start anchoring off the box. Both guarantees only cover what comes after them, so every month of delay is a permanently weaker prefix.
  7. 07

    Prove the restore before you need it

    Restore a snapshot and check the chain verifies against a head you recorded outside the system. A restore that lost its tail verifies clean against its own stored attestation, which is the failure this drill exists to catch.

Is a hosted governance product ever the right answer?

Yes, where the alternative is no control at all, and where the payloads in question are not the ones your data protection officer worries about. The honest comparison is not self-hosted against hosted in the abstract but against the specific arrangement on offer: which data crosses the boundary, what the contract says about it, whether the vendor can produce the evidence record on request or you can, and what the vendor’s own availability commitment is worth. What should not happen is arriving at a hosted deployment by default because it was quicker to start, and discovering during a data protection impact assessment that every prompt in the organisation now transits a third party.

Does self-hosting remove the vendor from the legal analysis?

No, and any vendor claiming it does is overreaching. Token Observe’s own data-flow document draws the line precisely: supplying the software does not itself send customer data to the vendor, and that technical fact does not decide the legal roles created by evaluation terms, support access, incident handling or data a customer chooses to share. If you send a log excerpt in a support ticket or share a screen during an incident, that disclosure is yours and is governed by your support agreement. Counsel still has to decide whether a data processing agreement, a transfer assessment or sub-processor terms are needed.

What is the strongest argument for keeping the evidence in your own network?

That the evidence exists to answer questions about your organisation, so the party under examination should not be the party who has to ask a third party for the record. Keeping it in your network also lets you use the two mechanisms that actually resist an insider — keyed digests under a key held outside the database, and signed anchors published to a destination the database administrator cannot rewrite — under your own key custody rather than the vendor’s. The counter-argument is real and should be weighed: your administrators are now the adversary the design has to survive, and those two mechanisms are work you have to do rather than a checkbox.

How do air-gapped installs get model prices?

From a catalogue that loads at boot, additively, so an offline install is metered from its first request without reaching anything. A row whose key is already present is skipped, so a restart never overwrites a price an operator corrected by hand — with the stated cost that a shipped price is never refreshed in place on upgrade, which means stale but present. That trade is deliberate, because absent means zero and a zero estimate silently disarms every ceiling above it. Correcting a price on an offline install currently means updating the row directly; there is no write endpoint for prices, and the documentation that once said there was has been corrected rather than quietly changed.

What availability should we plan for?

Plan for one process with one write path, no replica set and no vendor-operated service level, because that is the supported shape rather than a temporary state. A PostgreSQL adapter exists as an evaluation alternative and is explicitly not a high-availability topology, and there is no point-in-time recovery claim — recovery is from a retained full snapshot. In practice that means the availability engineering is yours: sizing the host, monitoring the disk, alerting on the readiness gate, and having a written answer for what happens to agent traffic while the gateway is being upgraded or restored.

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