An agent has prepared several changes that reviewers accepted with little correction. The team would like it to carry more of the work through without waiting. That's a reasonable opportunity to explore, but a successful patch answers only part of the question. Reviewers may have been supplying missing context, catching errors, or quietly deciding when a release could proceed.
The decision is about the workflow, not whether a model is generally trustworthy. What work can proceed, what still calls for judgment, and how will the team respond when an attempt doesn't go as expected? Different answers can make sense for different services, even when they use the same agent.
Choose the next decision to delegate
A recent completed change helps reveal what people contributed. Perhaps the implementation was routine but someone had to negotiate compatibility with another team. Delegating implementation won't remove that negotiation. If the main delay was a person checking a predictable condition, an enforced check may let that part proceed without another interruption.
The GitLab Security Standard describes three choices: suggest, propose, and act with guardrails. An agent might recommend work for a person to carry out, prepare a change for human approval, or complete agreed work with people handling exceptions. These choices apply to workflows, not rankings of teams.
Consider a dependency update in a well-understood service. The team might allow an agent to prepare and test the patch, while retaining a release decision during a busy trading period. Later, the same kind of update might proceed automatically during agreed hours. A change to the release rules themselves would still need separate review. The task's name hasn't changed; the circumstances and authority have.
Agree what proceeding without another approval means
“Handle routine updates” leaves too much for each participant to infer. A more concrete agreement names the supported projects, kinds of change, checks, and point where the agent should ask for help. It also covers how much work can start at once. A mistake repeated across fifty projects is a different recovery problem from the same mistake in one branch.
The person responsible for the service should be able to explain that agreement and change it. A reviewer shouldn't have to infer permission from an agent's confidence or from the fact that an earlier request succeeded. Existing approval requirements still apply until the responsible people deliberately change them through the normal review process.
Missing information should lead to a recognizable next action. An update that needs a compatibility decision can wait for the owning team; a failed integration can stop the attempt for investigation. Neither calls for the agent to seek broader credentials or remove a check so it can finish. Coordinating human and agent work explains how to make those handoffs understandable.
Look beyond the changes that will be reviewed
The proposed patch isn't the only thing an agent can affect. While investigating, it may read files, run package installers, contact services, or send information through a tool. Those actions happen before merge request review. Access should fit the task even when someone plans to review every line of the resulting code.
For example, an agent updating a library may need a package registry and the project's tests, but not production credentials or unrestricted access to the developer's home directory. An MCP connection deserves the same scrutiny as any other tool: which operations it exposes, whose access it uses, and where information can go. A fresh workspace helps with leftover files; it doesn't by itself limit network access or credentials.
Those choices should hold when an input misleads the agent. An issue comment or tool result can contain instructions that conflict with the task. Clear project guidance helps the agent interpret them, while permissions and execution controls limit what it can do if that interpretation fails. GitLab's agent security guidance explains why the execution environment matters.
Examine the decisions a successful run didn't exercise
The team's usual tests remain important, but the evaluation should also exercise the situations that previously brought a person into the work. What happens when a required check is unavailable, the request changes during an attempt, or a retry finds an existing merge request? Building feedback into delivery explains how to choose cases that could change the delegation decision.
A passing result shouldn't depend on the agent rewriting the rule that judged it. Tests can legitimately evolve with code, but changes to required checks, approval rules, and release permissions need review outside the authority being exercised. Independence concerns who can change the decision, not just whether a second agent participated.
The end of the workflow matters too. If the goal includes release, follow the accepted change through the artifact actually deployed and the behavior users receive. Rebuilding after approval or leaving an external deployment unchecked breaks that connection. Deployment and recovery practices explains how to preserve artifact identity and prepare for a failed release.
Keep the choice reversible
A limited introduction gives the team time to learn without making every service part of the experiment. Choose work with a clear outcome and include enough variation to expose repeated corrections, delays, and exceptions. A workflow that succeeds because a maintainer repeatedly rescues it may still benefit from assistance, but hasn't removed that maintenance work.
Before widening the work, have the people operating it practice an interruption after some actions have completed. They need to find what changed and recover, including work delegated to other systems. Operating the team's AI capabilities covers that response.
Autonomy can increase, stay where it is, or decrease as the work changes. A new tool, broader access, or a different service may introduce decisions the earlier experience didn't cover. After a failure, correcting the cause and repeating the relevant cases gives the team a reason to resume; merely restarting the agent doesn't.
The final question is whether the arrangement improves delivery enough to justify its full cost. More completed attempts aren't the same as resolved customer problems. Review time, unsuccessful work, operation, and recovery all remain part of the investment. Keeping a human decision can be the better design when it saves more effort than it adds.