As agents take on more implementation work, producing a change becomes only part of the challenge. Teams also need to know that it solves the intended problem, respects their decisions, and can reach users without creating more work than it removes. Faster generation makes that judgment more important, not less.
Agentic delivery brings those relationships into focus. People decide which problems deserve attention and what a good result would mean. Agents can help investigate, plan, implement, and check the work. As either learns something new, that understanding needs to reach the others. The result depends on how well the whole process works, not just on how quickly an agent finishes its part.
From individual assistance to a connected delivery process
A conversation that helps someone understand a problem can be a complete success. So can a delegated change that proceeds through several stages before someone reviews it. These approaches can coexist within the same organization, and even within the same piece of work. The degree of autonomy is a choice about the work, not a measure of the team's sophistication.
At a larger scale, this becomes a governed software factory: a delivery process that carries intent through planning, implementation, checking, and release while preserving the organization's decisions about quality and responsibility. Connecting more agents won't produce that arrangement by itself. The work needs current context, coordinated handoffs, dependable checks, and a way to recover when an attempt goes wrong. What happens after delivery then informs the next decision.
GitLab's role in this discussion extends beyond where an agent runs. Work items, repositories, merge requests, pipelines, and operational records can connect the reason for a change with what was done and what followed. GitLab Duo Agent Platform and external agents participate in that work alongside people and conventional automation. The design question is how to preserve those relationships as the participants and tools change.
Autonomy that fits the work
A team can delegate more of a workflow when it understands both the results and how failures are handled. A routine update with reliable checks and straightforward recovery presents a different choice from a change to the rules that approve releases. Autonomy is permission for particular work under agreed conditions, not a permanent property of an agent.
The GitLab Security Standard brings together authorization, isolation, verification, release, and response. The recommendation on workflow autonomy explores how to make those choices in practice, including when to keep a person involved and when to reduce delegation.
These decisions connect to the other pillars. Platform governance establishes who can authorize work; collaboration keeps its purpose and review understandable; CI/CD carries the accepted change into a release; security follows weaknesses through remediation; and measurement asks whether the whole process improved. AI changes the pace and participants, but doesn't remove those responsibilities.
Better delivery, not a target for more automation
The opportunity is broader than completing today's backlog with fewer manual steps. Work that once cost too much to attempt may become practical: investigating more alternatives, maintaining neglected systems, or responding to needs that previously waited. That opportunity still depends on judgment about what to pursue and whether the result helped.
Teams can begin where a real delivery problem meets a practical opportunity for improvement. They don't need to redesign their organization before using an assistant, nor assume that the first successful use should expand everywhere. A faster implementation stage may reveal a review bottleneck; a better planning process may prevent unnecessary implementation altogether.
The design principles explain the reasoning behind these choices, and the recommendations offer ways to put them into practice. The AI-assisted and agentic delivery checklist can help your team find a starting point. The other Best Practices pillars remain relevant whether or not you use AI.
Further Reading
- When code is abundant explores how faster implementation changes the work around it and why different degrees of autonomy can coexist.