Why are prompts not governance?
Most teams govern their AI the way they first adopted it: with words. The process lives in a system prompt, the rules live in a paragraph that says "always" and "never," and the checkpoints live in phrases like "wait for approval before proceeding." This works right up until it matters, because every one of those controls is advisory. A language model can misread, deprioritize, or talk itself past an instruction, and when it does, nothing stops the action and nothing marks the miss.
Governance begins where advice ends: at controls something other than the model evaluates. The question to ask of any AI control is "who checks this?" If the answer is "the model, by reading it," you have a request. If the answer is "an engine, on every action," you have a rule.
in the prompt read by the AI
Shipped. Nobody said yes.
as a gate checked by the engine
Waiting for approval.
How is governing AI agents different from traditional IT governance?
Traditional IT governance assumes software does what it was written to do. You review the code, control who can deploy it, give each system a service account, and read the logs when something breaks. The behaviour is fixed between releases, so controlling the release controls the behaviour.
AI agents break that assumption. The model decides inside each step, the same prompt can produce different actions on different days, and the agent often acts under a person's sign-in rather than its own. Editing one instruction changes what the system does with no release at all. Governance therefore moves from the code to the work: what steps the agent is given, where it must stop, what it must record, and whose authority it acts under.
The table below sets the two side by side. None of the traditional controls goes away. Each one gains a counterpart that applies while the agent is working, not only before it is deployed.
| Concern | Traditional software | AI agents | What the control becomes |
|---|---|---|---|
| Behaviour | Fixed between releases | Decided by the model inside each step | Control the steps and the stops, not each output |
| Change | A release changes the code | An edited prompt changes behaviour with no release | Keep the process and its rules in one place where every edit is recorded |
| Identity | One service account per system | An agent acting under a person's sign-in | Record the agent and the person as two separate names |
| Access | Least privilege by role | Agents holding the keys of whoever started them | The platform holds keys and gives each run only what it needs |
| Evidence | Logs and tickets | Transcripts nobody has time to read | Numbers and reports recorded at the step, with evidence attached |
Step one: how do you make the process structural?
The unit of governance is the process, not the prompt. Write down how the work should go, once, as a sequence of steps with instructions, and store it where an engine can execute it. This does three things no prompt can: the process becomes inspectable (anyone can read what the system does), editable in one place (change a step, every future run inherits it), and enforceable (the engine knows where the run is and what must be true to continue).
A practical test of whether your process is really structural: can a run be resumed by a different agent, or a different person, from exactly where it stopped? If resuming requires re-reading a transcript to reconstruct state, the process lives in the conversation, not in structure.
Step two: where should gates go?
A gate is a condition the engine checks before allowing the process to advance: a human approval, all child work finished, a required record written. Gates are the difference between a process the model is asked to follow and one the engine checks on every attempt to move on.
Place them by consequence, not by anxiety (where approval gates belong covers the patterns). A gate belongs where a wrong advance is expensive or irreversible: the release, the outbound email, the publish, the deletion. It does not belong on every step; a process that stops constantly teaches its operators to rubber-stamp, which is governance theater.
Gates are checkpoints you choose. Add them where a person, a metric or a report should decide. Leave them out where the work can run by itself. Because a gate lives on a step, adding one or taking one away is an edit to the process, and the change is in the workflow's history rather than in someone's memory of a prompt. In a self-improvement loop, put an approval gate on the step that applies a workflow change, and the change waits there until an explicit approval is given.
Step three: how do rules reach the agent at the moment of action?
Standards fail by being elsewhere. The style guide is in a wiki, the security rule is in a doc, the prompt paste is three versions stale. The fix is delivery, not repetition: attach rules to the process as policies, so that the rule appears inside the step where it applies, at the moment the agent executes that step.
This inverts the maintenance burden. Instead of hunting down every prompt that embeds a rule, you edit the rule once and every governed workflow picks it up mid-flight. Be precise about what this mechanism is: delivered rules inform the agent in context; they do not physically block. Blocking is the gate's job. In ConvOps, what stops a step is a gate, or a metric or a report the step is required to produce. A governance story that keeps that distinction honest will survive its first serious audit; one that blurs it will not.
Step four: why keep two identities in the audit?
Every action in an AI system has two authors: the automation that performed it and the human under whose authority it ran. Auditing collapses when these blend, because "the agent did it" is not an accountability answer.
The design that holds, called dual attribution: record the agent as a label it declares (useful, honest, but a claim), and record the human server-side from the verified credential, with no input path through which a caller could supply it. When the human identity cannot arrive in a request, it cannot be forged by one, and your audit rows become evidence rather than narration.
Then scope your coverage claims exactly: field-level before-and-after on the surfaces agents mutate is a strong, checkable statement, and the AI agent audit trail guide lists the fields. "Everything is audited" is a marketing sentence waiting to be falsified.
Step five: why isolate systems from each other?
The first autonomous system is an experiment; the third is an operations portfolio. Govern them like one: each system in its own workspace with its own process definitions, rules, execution configuration, and memory, isolated at the storage layer, so a mistake in one cannot leak into another and a client's system can run under stricter rules than your internal ones.
Unify the operator view, not the data: one identity across systems and one search across them, with every write landing in exactly one. Shared visibility with separated ownership is the shape that scales.
What are the five controls for AI agents?
The five steps above describe how to design a governed process. Once it runs, the same ideas reduce to five controls you can name, check and show to an auditor. Each answers one question about every agent action: who acted, what could it reach, where did it have to stop, what did it record, and what trail does it leave.
A useful property of these controls is that they can be strict where the risk is and light elsewhere. A new requirement can start by being watched before it is allowed to stop anything, so you learn how often it would have fired before it holds real work.
- 1
Identity and keys
Every action names the agent and the person it ran for, and model keys belong to the platform, not to the runner. In ConvOps, provider keys are stored encrypted, given only to the run that needs them and masked in what it returns. Example (Enterprise): a bank keeps separate provider accounts for production and sandbox work, and no runner ever holds either key.
- 2
Least privilege
An agent gets only the access its step needs. In ConvOps, agent git access defaults to none: the agent commits, and ConvOps pushes when the run ends, to a destination the prompt cannot change. Full access, where the agent pushes its own work, is a setting you choose per environment. Example (Software delivery): review agents work on a task branch and never touch the main branch.
- 3
Checkpoints
Gates hold a step where a wrong move is expensive. A gate holds the step until an explicit approval is given, recorded with the account that gave it, or until child work finishes or a reason is written down. Example (Finance operations): the month-end close runs on its own until the step that posts adjustments, where a controller approves.
- 4
Metrics the work must report
Define the numbers the work must report, and bind each one where it applies: the workspace, a project, a workflow or a single step. In ConvOps, a metric or report bound in enforce mode holds the step until it is recorded or filed, with a link or note as evidence where the binding asks for one, and observe mode records whether each step would have met it without stopping anything. The system also records what it observed itself, such as run cost, duration and outcome, and agents cannot write those. Example (Support): every reply run records whether the ticket was resolved, with the ticket link as evidence.
- 5
Audit trail
Every change keeps a before and after, with the two names. In ConvOps, field-level diffs cover tasks and workflow instances, and per-step history adds the decision and reason recorded at each step. Example (Enterprise): a compliance team answers "who changed this, under whose sign-in, and why" from the record, without rebuilding it from chat logs.
What belongs on an AI agent governance checklist?
Take one process your team already runs with AI. The table turns each control into a question and names the evidence that answers it. If you cannot point at the evidence, the control is a hope. Then ask the five questions below of the same process.
| Control | Question to ask | Evidence that answers it |
|---|---|---|
| Process | Is the process stored as steps an engine runs? | The workflow, readable by anyone on the team |
| Checkpoints | Does the run stop where a wrong move is expensive? | A gate on that step, and the refused advance when it was not met |
| Rules | Does a rule change reach runs already in progress? | One policy, bound where it applies, delivered at the next step |
| Metrics | Are the metrics the work must report defined and bound? | Each binding, the recorded values with evidence, and which required ones are still due |
| Identity | Can you name the agent and the person for any change? | Audit rows with two separate fields, one taken from the sign-in |
| Isolation | Can a mistake in one system reach another? | A workspace per system, separated at the storage layer |
- Is the process stored as structure an engine executes, or as prose a model reads?
- Where are the two or three moments a wrong advance is expensive, and does the run physically stop there?
- When a rule changes, how many places must you edit, and how do runs already in progress learn about it?
- On any given action, can you name the automation AND the verified human, separately?
- If you ran it forty times unattended, what record would exist, and what would it cost?
Frequently asked questions
How do you govern autonomous AI systems?
With controls the model cannot talk its way past, checked by something other than the model. Store the process as steps, place gates where judgment is required, deliver rules at the moment they apply, record two identities on every change, and keep each system in its own workspace. In ConvOps, each of those controls is a setting on the workflow, so a run cannot skip a gate it was given.
How do you control AI agents?
Give the agent one step at a time from a stored process, place gates where a wrong move is expensive, define the metrics and reports that prove the work and bind them where they apply, keep keys with the platform, and record every change with two names. In ConvOps, a refused advance lists exactly what is missing, so the agent or the person watching knows what to do next.
Are written policies enough to govern AI agents?
No. ConvOps delivers a policy inside the step, so the agent has the rule at the moment it applies, but a policy does not stop a step. What stops a step is a gate, or a metric or report the step is required to produce. Keeping that line clear is what lets the governance story survive an audit.
How often should a governed AI agent stop for a person?
As rarely as the risk allows, and in ConvOps each stop is a gate on one step, so adding or removing one is a single edit. Put a gate where a wrong advance is expensive or hard to undo, such as a release, a payment, an outbound message or a publish. A process that stops constantly teaches people to approve without reading.
Can ConvOps show an auditor who did what?
Yes, for tasks and workflow instances. ConvOps keeps a field-level before and after for every change, with the agent label the client declared and the user taken from the verified sign-in, which no request field can set. Per-step history adds the decision and the reason recorded at each step. The audit is read in the web app and over the REST API.
Who is this guide to governing AI agents for?
It is for the people accountable for AI agent work: operations leads, engineering managers and compliance owners who need agents to follow a process and leave a record. The guide shows how ConvOps makes that concrete with workflows, gates, policies, metrics and an audit trail. You end up with a checklist of controls and a way to check each one on your own runs.