Adding an agent to one task can save effort without changing how the team coordinates its work. That becomes harder when several agents can investigate, implement, and revise changes at the same time. Work may move quickly inside each task while waiting, duplication, and conflicting decisions accumulate between them.
A connected approach begins with how the team wants work to proceed. The aim is to make responsibility and progress understandable whether the next participant is a person, an agent, or an automated check. You can introduce that approach gradually; it doesn't depend on having a single orchestrator for the entire lifecycle.
Understand how a change reaches its outcome
A recent change is often a better starting point than the process diagram. Following it from the original request through delivery and subsequent feedback can reveal where someone had to reconstruct context, wait for a decision, or repeat work. The people involved can explain which of those steps protected an important concern and which existed because the tools didn't connect.
The intended result gives that investigation a focus. If customers are waiting too long for fixes, faster code generation matters only if the fix reaches them sooner without creating another problem. A release constraint, incomplete request, or shortage of reviewers may deserve attention before implementation capacity increases.
That view also helps with work that spans projects. Dividing a change by repository can make assignments convenient while hiding dependencies between them. The team needs to understand which parts can proceed independently and which require a shared decision or an agreed order.
Decide what agents can do and when people step in
For each part of the work, someone should be able to explain who can decide what happens next. The person who requests an outcome may not be the person who can authorize a production change, and an agent's permission to propose a change doesn't imply permission to release it.
The people who understand customer priorities can decide which outcomes to pursue, engineers can assess implementation choices, and those responsible for a service can decide how a change reaches its users. Your team may combine these responsibilities, but delegating the work doesn't remove them.
The access given to an agent should fit the task. An investigation may only need to read code and issue history; preparing a fix may also need permission to create a branch. Using a person's everyday credentials can give an agent access unrelated to that work. The team should be able to tell whose access the agent is using, what it allows, and who can withdraw it. This applies even when a person is actively chatting with the agent.
The same expectations need to hold when one agent hands work to another. Delegating part of a task shouldn't grant more access than the task allows. Keeping the request, approvals, acting identities, and resulting changes connected gives someone investigating a problem a way to understand the decisions without reading every conversation.
Human review works best when it arrives with a question someone can answer. A reviewer needs the intended result, what changed, which checks ran, and what remains uncertain. Repeatedly asking for approval without that context turns oversight into an interruption rather than a decision.
Some transitions can proceed on conditions the team has already agreed. Others still require judgment. Those conditions should be enforced by the systems that control the action, rather than relying solely on an agent to remember an instruction. A manual handoff can remain the appropriate choice where the available integration doesn't preserve the control the team needs.
Someone also needs the authority and means to pause or stop the work. It's worth checking what that intervention does before depending on it: does it prevent new actions, stop an active attempt, or leave delegated tasks running? Recovery includes accounting for changes already made, not just confirming that the conversation ended.
Let the next participant continue without reconstructing the conversation
A handoff should make the next action clear. The receiving person or agent needs to find the current plan, completed changes, outstanding questions, and any checks that affect whether work can proceed. Links to the work itself are usually more dependable than a summary that becomes its only record.
GitLab work items and merge requests can provide that shared record. An agent session can explain an execution attempt, while the work item explains the task across attempts. Keeping that distinction helps the team recognize that a stopped session may have left changes behind, or that a finished session still requires review.
The same reasoning applies when planning or operations happen outside GitLab. A connection needs to preserve which record the team relies on for a decision and how updates reach the other participants. Copying information once doesn't keep two systems aligned. A link and a deliberate handoff may be easier to maintain than an unreliable automatic synchronization.
An engineer using a terminal-based agent still needs a way to bring that work into the team's review process. The merge request can connect the request, important decisions, changes, and check results without reproducing the full chat. Checks before merging help assess the proposed change, but they don't control what the external tool could read or do beforehand. Its credentials and tool access need attention too.
If people routinely work around the supported process, the reason is worth understanding. They may be waiting for access, repeating context, or losing time to slow feedback. A supported route that helps them finish the work is more likely to be used than one that only adds reporting. Improving it can preserve people's choice of tools while making the work understandable to the rest of the team.
Match concurrency to the whole team's capacity
Parallel work pays off when its results can be integrated and assessed. If review or testing becomes the slowest stage, launching more implementation work can increase waiting and make plans stale before anyone acts on them.
Teams can use the amount of unfinished work to decide when to start more. That may mean limiting simultaneous changes to a shared component, reserving review time, or improving test feedback before increasing agent activity. There isn't a universal concurrency number; the practical limit depends on dependencies, feedback time, and the team's ability to understand the work in progress.
Overlapping work needs attention before it creates conflicting changes. If two requests address the same defect, both agents may act correctly against their own instructions while producing duplicate changes. Visibility into current work, plus a way to claim or assign responsibility, helps prevent that. For changes that interact, reviewing the combined behavior is still necessary even when each change passes its own checks.
Plan for interruption and changed decisions
Failure isn't always a clean stop before anything happened. An agent may create a branch, update an issue, or open a merge request before a later action fails. Recovery starts by examining the current state, then deciding whether to continue, revise, or undo what already exists. Repeating the original request without that check can create duplicate work or overwrite a correction.
The surrounding workflow can make recovery easier by retaining links to actions taken and recognizing an existing result on a repeated request. Tool-enforced protections are stronger than a prompt asking the agent to avoid duplication. If a step can't be repeated safely, the next attempt needs a decision about how to resume it.
Changes of intent require similar care. When a request is withdrawn or a design decision changes, whoever owns the task needs to find connected work and decide what to keep or revise. A stopped agent may already have opened a merge request that someone else is reviewing; that person needs the new decision too.
Expand when the connected process improves
A first improvement can join two stages that repeatedly lose context or require avoidable manual coordination. The team can observe whether the handoff becomes easier, whether errors are caught, and whether someone can recover from interruption. That experience is more informative than demonstrating a long chain once under ideal conditions.
Further delegation can follow where the results support it. If work completes faster but reviewers can't explain what happened, the next improvement may be clearer summaries and records. If retries dominate the effort, better task context or a more reliable integration may help more than another agent.
Over time, these choices can support a software-factory approach in which work continues through connected stages and feedback informs new work. The objective remains better delivery. The team should be able to keep an effective human-led or assisted stage without treating it as a failure to automate.
Further Reading
- GitLab Duo Agent Platform sessions explains how to inspect and manage individual executions.
- Security threats in agentic systems helps assess the interaction between agent instructions, tools, and access.
- Evaluating business value and the cost of delivery helps assess whether changes to coordination improve the overall result.