An AI agent is software that takes a goal, plans a sequence of steps to reach it, and executes those steps through tools and other systems without a person authorising each one. In a development team those steps are edits across files, test runs, pull requests and calls into other services, and the definition matters because it moves oversight away from the words a model returns and towards the actions a system takes.
InfoWorld published an account of that move this month, contributed by Kirill Skrygan, who leads JetBrains. The argument it makes is that governance has to stop being a document sitting above delivery and become a set of controls sitting inside it. For anyone who owns a repository where an agent can already open a pull request, the practical version of that argument is the part worth reading, because the answer cannot be to review everything the agent does.
Why the review habit that worked for code suggestions fails on agents
A suggestion is easy to govern because the decision and the action are the same keystroke. The assistant proposes a function, the developer reads it, and accepting it is the moment responsibility transfers. The whole apparatus of review, the diff, the second pair of eyes, the line in the history that carries a name, was built for that shape of work.
An agent has a different shape. It edits several files, runs the suite, reads the failures, edits again, opens the pull request, and may call a deployment tool or a ticket tracker on the way through. InfoWorld describes the effect precisely: the distance between deciding and doing shrinks, and having a developer inspect every intermediate step is not a workflow that scales across teams. What replaces inspection is a narrower duty. The developer decides what to hand over, what context the agent needs and how the result gets verified. InfoWorld states the distinction directly: "a developer can delegate a task without delegating responsibility for the outcome."
The regulatory calendar has made that duty sharper. The European Commission's AI Act pages show the high-risk obligations moving again, to December 2027 for the sensitive-area list and August 2028 for systems embedded in regulated products, which leaves a long stretch in which agents doing consequential work fall to their operators (European Commission). Brookings makes the same point about the interim: organisational controls will carry the weight in high-stakes domains while the law catches up, and the questions that matter have changed from what a model said to what a system did, why it was permitted and who answers for it (Brookings).
The United Kingdom arrives at a similar place by a different route. There is no single AI statute, only five principles applied by existing regulators, which sounds permissive until you look at what is already binding. The UK AI Regulation Guide published by nhimg.org sets out the position: the data protection provisions on significant decisions made solely by automated processing have been in force since February 2026, and a person who rubber-stamps an agent's output is unlikely to be treated as meaningful human involvement (nhimg.org). That is the sentence to remember at the point of approval. Signing off a change without the means to interrogate how it was produced is not oversight, and it will not read as oversight afterwards either.
The pattern met most often in review is a pull request that reads cleanly next to a run that cannot be reconstructed. The first is a code quality problem. The second is a governance one, and it is the one this piece turns to now.
What to build into the pipeline before you widen an agent's permissions
The controls that survive contact with delivery work are the ones a platform team builds once and every repository inherits. Four carry most of the weight, and each has a failure mode that appears within a month of an agent being given real access.
- Begin with a trace that reconstructs the run. A record that says which agent acted, under which identity, on whose instruction, which tools it called, which tests it ran and where a human approved it. A Cloud Security Alliance research note explains why this is harder than it looks: one task can span a dozen tool calls and a write to a production API, while the reasoning that chose those calls stays inside the model and out of conventional logging (Cloud Security Alliance).
- Give every agent a named owner with the authority to stop it. Ownership is not a review rota. The owner is the person who can revoke the agent's credentials at two in the morning and who has to explain the run afterwards. The same nhimg.org guide maps its accountability principle onto agents that hold credentials or touch personal data, and asks for a named human who can explain and switch off each one.
- Scope permissions to the job, and let the identity system enforce them. A distinct identity per agent, short-lived credentials, no standing route into production, and scopes that match the task.
- Put cost and outcome on the same record. InfoWorld describes the emerging software harness, a layer around the model that supplies context and bounds what a task can spend. The detail worth taking is the pairing, cost next to output, so that a team can say whether a merged change, a caught defect or a shorter incident justified the autonomy behind it.
Scope is the control that decides whether the other three mean anything, because it is where intent becomes configuration. Written into the repository, a scope declaration is short enough that a reviewer will actually read it:
agent: migration-bot
owner: payments-platform
identity: sp-migration-bot
credentials: short-lived
scopes:
- repo:read
- repo:write:branch
- ci:run
deny:
- deploy:write
- secrets:read
Where the approval gates sit is a decision each organisation has to make before an agent tests it, and the useful discipline is to write the ladder down. Reading a repository and running the test suite inside a sandbox needs no gate at all. Opening a pull request against the default branch needs a reviewer who can read the diff and the trace behind it. Changing deployment configuration, infrastructure definitions or the permissions held by another system needs an explicit approval from someone named in the service's ownership record. Rotating credentials, deleting data or touching production needs that approval and a check afterwards that what ran matched what was approved.
None of this holds if it is built team by team. InfoWorld's closing observation is the one engineering leaders should take into their next planning round: what works when one developer directs one agent does not survive many agents across many repositories and shared systems without common standards for permissions, traceability and approval. Info-Tech Research Group goes further and argues that approval-based governance cannot keep pace with agents at all, and that control has to be continuous at runtime, with the operational space narrowed by tiering agents on access, autonomy and business impact (Info-Tech). The two positions agree on the point that matters. A control that lives in a wiki is a preference. A control that lives in the identity provider, the merge queue and the runtime monitor is governance.
The competitive question is not how many agents a team can run. It is how much work a team can hand over and still answer, months later, who allowed this, what it did and what came of it. Teams that can answer get more autonomy. Teams that cannot get more process, imposed by someone with less context than they have.
Sources
- How AI agents are changing the rules of software governance
- Shaping global governance of AI agents
- AI Act | Shaping Europe's digital future
- UK AI Regulation Guide: Principles, Code and Law
- The AI Agent Governance Gap: What CISOs Need Now
- Govern Enterprise AI Agents While Preserving Innovation
a developer can delegate a task without delegating responsibility for the outcome.
Source: How AI agents are changing the rules of software governance, InfoWorld


