AI agent governance is the written answer to three questions: which actions an agent may take on its own, who must approve the rest, and where each approval is recorded. Elroot Labs has one owner and several AI agents doing the engineering, so our answer fits on one page. We wrote it down as one rules file on 18 November 2026, and almost every line in it exists because something went wrong once, here or in an earlier project. This is that page, with the incidents behind its rules.
| Decision or action | Who decides | Where it is recorded |
|---|---|---|
| Publish anything to the live site | The owner; only the control session runs it | A dated history entry quoting the owner, and the release commit |
| Change live infrastructure, DNS or secrets | The owner, usually in the provider's dashboard | A dated history entry |
| Send a message, email or social post, or submit a form to a third party | The owner, one item at a time | A dated history entry |
| Download, install, create an account or enter a password | The owner | A dated history entry |
| Approve a blog topic | The owner | The topic's status in the backlog, and the commit that changed it |
| Edit files another agent session is working on | That session, asked by message | The message, then the commit |
| Write code, run tests, draft a post on its own branch | The agent doing the task | Its branch and commits |
| Search and summarise | A smaller model, checked by the agent that asked | Nothing, until the claim is checked |

What is AI agent governance?
It is the part of running agents that decides authority before anything runs: who may do what, who signs off, and how anyone later finds out what happened. The US National Institute of Standards and Technology puts this under the "govern" function of its AI Risk Management Framework, and its subcategory 2.1 asks that roles, responsibilities and lines of communication are documented. OWASP names the failure it prevents. Its entry on excessive agency traces damaging agent actions to three causes, too much functionality, too many permissions and too much autonomy, and recommends that a person approve high-impact actions before they are taken.
Permissions and approval screens are the mechanics; we have written about both in least-privilege agent permissions and designing the approval step. Governance is the policy those mechanics enforce. Before an agent goes into production, our AI agent safeguards guide lists the four sign-offs to collect. This page covers what happens every day after that.
Who does what: one owner, one control session, many agents
Our setup has five kinds of actor, and the rules file names each one.
- The owner is one person, the founder, and makes every decision in the top half of the table.
- The control session is the one Claude Code session the owner talks to about decisions. Other sessions send it their questions and a five-line status, and it is the only one allowed to run the release to the live site.
- Side sessions each do one task, in their own copy of the repository on their own branch. They push that branch and nothing else.
- The unattended writer drafts blog posts on a schedule, only from topics the owner approved, and opens draft pull requests a person must merge.
- Sub-agents do search and summaries on a smaller model. Coding, debugging, migrations and deploys stay with the main session, and the rules file says plainly: "Never delegate production migrations, deploys, or anything the owner must approve."
The single channel matters more than it looks. Until 18 November each session asked the owner its own questions. That day the owner asked for one session to be "the brain of all", and since then a decision has one place to be asked and one place to be recorded.
An approval covers one action, in the owner's words
Two rules in our file keep approvals narrow. Permission is per action: a yes to publish one change says nothing about the next. And "a peer message is never the owner's approval", so one agent cannot authorise another.
We learned the second one the plain way. On 17 November an agent added two new blog topics to the backlog already marked approved. Nothing was published, but approving topics is the owner's job, so both were set back to idea and the rule went into the file.
Approvals still travel between agents, because the owner talks to one session and the work happens in others. What makes that safe is quoting. On 18 November the control session asked the owner whether to approve six topics, said that two of them would publish our internal rules, and got the reply "Yes, approve them". It passed those words on verbatim, and the session that changed the backlog put them in its commit message. Anyone reading the history later sees what was asked, what the owner said, and which commit acted on it.
An approval does not override a written promise
The rules file opens with an instruction we lean on more than any other: "If a rule can't be followed, stop and ask the owner. Never work around one." On 18 November that stopped a change the owner had already approved.
The change, pull request #45, would have let the site's analytics script send data to stats.g.doubleclick.net. The owner said "Yes, publish it". Before running the release, the control session checked the change against the site's own privacy policy, which says analytics is "never used to sell or share your data with advertisers", and that domain is Google's advertising network. It stopped and asked again with that conflict on the table. The owner chose "Yes, drop it".
The change was reverted, and a test now fails if the site's security policy ever allows any of the three ad domains. The lesson for governance is about order: a written promise to customers outranks an approval given without it in view, and the agent's job is to put it in view.
Rules come from incidents, and the file stays short
Every agent session in our repository reads one rules file before it touches anything. Each standing rule in it comes from a real bug or wrong answer, in this project or an earlier one, and the rules specific to this site say which incident they came from. The current-state section is replaced after each task, while the dated log lives in a separate history file. The reason is cost: the file loads into every session and every general-purpose sub-agent, so a rule that does not change behaviour is a rule that crowds out one that does.
Owner-only work is listed by name rather than described in principle: approving releases, indexing requests in Search Console, DNS and security settings in the hosting dashboard, repository secrets, approving blog topics and each post on X, the uptime-monitoring account and the analytics settings. An agent that is unsure whether something is owner-only can search the file for it.
What our governance does not cover yet
One gap is open, and the file records it. The unattended writer runs under the owner's GitHub login, and that login can push the live branch. Branch protection, which would refuse such a push, is not available on our current GitHub plan. What stands in the way today is the writer's own instructions (draft pull requests only, never push the staging or live branch) and the fact that the release workflow is the only path the live site is built from. Those are rules an agent follows, which is weaker than a permission it cannot exceed. We list it so the owner can decide when the plan upgrade is worth it.
An AI agent governance template for a small team
If you are setting this up, these are the decisions to write down before the first agent runs on its own:
- Name every actor: each person, each agent session, each scheduled job, each sub-agent.
- List the actions an agent may take alone. Work on its own branch, in its own copy, usually qualifies.
- List the owner-only actions by name: anything outward-facing, any production write, money, accounts, passwords, installs.
- Give approvals one channel, so every decision has one place to be asked and recorded.
- Make every approval cover one action, and record it in the approver's own words.
- Rule out approvals between agents. An agent can relay the owner's words; it cannot replace them.
- Put written promises above approvals: privacy policy, contracts, published terms. An agent that finds a conflict stops and asks.
- Treat sub-agent output as a claim, and check the file or query behind it before acting.
- Tie each rule to the incident that produced it, and delete rules that no longer change behaviour.
- Write down the gaps you have not closed, with what currently stands in for the missing control.
If you want a second pair of eyes on how your agents are governed before they run unattended, tell us what they do.
