AI agent governance holds in a delivery pipeline only when the pipeline can tell which changes an agent made and which person sent the agent to make them. Jennifer Riggins asks engineering leaders three questions about agentic AI in a recent article, and this piece follows one of them: who owns what the agent builds.
Riggins reports that agent accountability lives in policy documents more often than in controls
Riggins cites an IBM Institute for Business Value finding that 87% of organizations claim to have AI governance policies while fewer than a quarter have implemented controls. Eirini Kalliamvakou of DX advocates rules on what agents may do without a person, when a human must approve, and who is accountable. Riggins writes that such rules mean nothing without enforcement. Charlotte Fleming, a researcher at Octopus Deploy, says a deployment gate is what makes a policy happen, and that compliance has to run continuously in the pipeline. Her test is a short one: “Is our policy enforced or only written down?”
Kevin Storer, a former qualitative research lead at DORA, adds a harder problem. He says that in multi-agent architectures it becomes impossible to audit the trail of thinking, which leaves open whether an employee is at fault for a mistake an agent made under their watch. The article also covers developer wellbeing and the cost of delivery with agents, which this piece does not take up.
A gate can only enforce agent governance rules if it can identify the agent
Each of the three rules Kalliamvakou describes names an actor: the agent, the person who approves, and the person who is accountable. A deployment gate works from the record of a change. It reads who pushed the change, who approved it and which checks ran. If nothing in that record separates an agent from a person, a rule such as “agent-written changes to the payments service need two human approvals” has nothing to read. The policy exists, and the gate lets every change through.
That is the ordinary case when a coding agent runs on a developer’s laptop. The agent works inside the developer’s checkout with the developer’s credentials. Git’s own documentation says the commit author is taken from the user.name and user.email configuration items, so the commit names the developer. The hosting platform attributes the push to the account that authenticated, which is also the developer. From the pipeline’s point of view, no agent took part.
GitHub already enforces one agent accountability rule in its review logic
GitHub’s documentation on required reviews states that pull request authors cannot approve their own pull requests. It then adds a second rule: you cannot approve a pull request raised by GitHub Copilot if you were the person who assigned Copilot to the issue it relates to. That sentence is an agent governance rule enforced by the platform. The person who delegated the work is treated as its author for review purposes, so someone else has to approve it.
The rule works because the platform knows two facts. The pull request was opened by an identity it recognizes as the agent, and it has a record of which human assigned the task. Take either fact away and the rule cannot run. The same is true of the protected branch option, described in GitHub’s branch protection documentation, that requires the most recent reviewable push to be approved by someone other than the person who pushed it. When an agent pushes under its own identity, that option forces a human to approve the agent’s last change. When the agent pushes under the developer’s identity, the option only learns that the developer pushed.
Provenance records already separate the actor from the request
Software supply chain security handled a similar problem for builds. SLSA v1.0 provenance is defined as an attestation that a particular build platform produced a set of software artifacts. It records the platform in a builder.id field and the external interface to the build, meaning what was requested, in externalParameters. A verifier checks the builder identity before it trusts the artifact.
SLSA was written for build platforms, and it says nothing about coding agents. Its structure still fits the agent case. A change record that can support Kalliamvakou’s rules needs three separate fields: which agent acted, including the tool and its configuration; which person delegated the task; and what the task was. With those fields in place, the rules become checks a gate can run. A change from an agent identity needs approval from someone other than the delegator. A change from an agent identity to a sensitive path needs a second approver. A change with no recorded delegator is rejected.
Getting there is mostly an identity decision. Coding agents that push code run under their own service identity, such as a bot account or an app installation, with permissions scoped to the repositories they work in. The delegating person is recorded by the platform when the task is assigned. A note the agent writes into its own commit message is weaker evidence, because the agent controls it.
Agent identity answers who acted and leaves the reasoning trail open
This approach has limits. Storer’s concern is about the trail of thinking inside multi-agent systems, and a separate identity does not touch it. The record will show that an agent, sent by one developer, pushed a change that a second developer approved. It will not show why the agent chose that change. Where the reasoning matters, as in an incident review, teams still need the agent’s own logs, and those are only as complete as the tool makes them.
The identity can also be stepped around. A developer can copy an agent’s output and commit it under their own name. The gate then treats it as a human change. That is an accurate record of what happened, since the developer has taken ownership of the code, but it means agent metrics built on identity will undercount agent work. Separate identities also add credentials to issue, scope and rotate, and each one is a new thing that can be stolen.
What the record does provide is a definite answer to a narrower question than the one Storer asks. It shows who delegated, which agent acted and who approved. An organization can write rules against those three facts and enforce them on every change.
Why This Matters for Engineering Leadership
The IBM figure Riggins cites describes a gap between policy and control. In agentic software delivery, one concrete reason a policy can stay unenforced is that the pipeline has no way to see the actor the policy is about. From an AI governance view, that makes agent identity a precondition for the rest of the policy. A useful exercise for any engineering leader is to take one rule in the company’s AI policy that mentions agents and find the field in the pipeline record that the rule would read. If the field does not exist, the rule is a statement of intent. Give agents their own identities, record who sent them, and the rule becomes a check.
FAQ
What is AI agent governance in a delivery pipeline?
It is the set of rules about what coding agents may change without a person, when a human must approve, and who is accountable, enforced by checks that run on every change.
Why can’t a gate enforce rules about agents today?
Many coding agents run under the developer’s own Git configuration and credentials. The change record then names the developer, so the gate has no field that marks the change as agent-made.
Does any platform already enforce an agent rule?
Yes. GitHub’s documentation says you cannot approve a pull request raised by GitHub Copilot if you assigned Copilot to the related issue. The person who delegated is treated like the author.
How does SLSA provenance relate to agents?
SLSA v1.0 provenance records the build platform in builder.id and the requested inputs in externalParameters. An agent record can follow the same split: the agent, the person who delegated, and the task.
Does a separate agent identity solve accountability?
Only part of it. It records who delegated, which agent acted and who approved. It does not record why the agent made a choice, which remains hard to audit in multi-agent systems.
What should engineering leaders check first?
Pick one rule in your AI policy that mentions agents and find the field in your pipeline record that the rule would read. If no such field exists, the rule cannot be enforced yet.
