Division of work between humans and agents
How to distribute execution, decisions, and approvals between developers and AI agents, defining autonomy, checkpoints, and supervision.
Updated: November 14, 2026
Using AI agents allows a developer to coordinate different implementations simultaneously, distributing coding, investigation, testing, and review activities.
This capability changes how work is organized. Instead of directly executing every stage, the developer defines objectives, establishes autonomy limits, monitors results, and intervenes in decisions requiring their participation.
However, delegating a task does not mean granting unrestricted control to the agent. Autonomy to execute operations must be distinguished from authority to modify requirements, contracts, architecture, or shared resources.
The strategy is to distribute responsibilities so agents can work independently within defined boundaries without turning human supervision into a new bottleneck.
1. From individual execution to orchestration
A developer can coordinate different agents to implement parts of a feature, investigate problems, or prepare independent changes.
This allows work distribution without necessarily involving several developers in executing each stage.
However, organization must consider not only what can run in parallel but also the capacity to monitor results.
An implementation involving backend, frontend, and tests, for example, can be distributed among three agents provided contracts and dependencies are defined.
The developer can monitor results, resolve blockers, and coordinate integration.
But this distribution need not apply to every task.
A targeted change may be completed more efficiently by one agent without additional planning or coordination stages.
Orchestration should reduce the work needed to complete a delivery, not multiply executions without benefit.
2. Separating execution, decision, and approval
An important distinction is separating three responsibilities: executing, deciding, and approving.
Execution
Involves implementing code, modifying files, running commands, preparing tests, and performing other operations needed to complete a task.
These activities can be delegated broadly when the agent has appropriate instructions, tools, and permissions.
Decision
Involves choosing technical alternatives, changing contracts, modifying architecture, or interpreting requirements.
Some decisions can be delegated, especially when established standards exist and impact is limited.
Others require human participation, particularly when they affect shared components, business requirements, or significant architectural decisions.
Approval
Determines whether a change may be integrated, deployed, or used in a given environment.
This authority should follow project policies regardless of who performed implementation.
Practical example
An agent receives the task of implementing an endpoint.
It may have autonomy to organize functions, reuse services, and create tests.
However, if it discovers a need to change an API contract used by other systems, that decision may require approval before continuing.
Implementation remains delegated, but authority over the contract remains subject to project owners.
Execution autonomy does not mean unrestricted decision-making authority.
3. Autonomy levels and operational limits
Autonomy may vary according to the task, risk, and available tools.
A useful classification is:
| Level | How it works | Application |
|---|---|---|
| Assisted | The agent proposes changes and the developer follows relevant decisions. | Complex investigations or unfamiliar tasks |
| Supervised | The agent executes within defined limits and requests intervention at checkpoints. | Implementations with dependencies or moderate risks |
| Autonomous | The agent completes the task within authorized scope and prepares results for validation. | Well-specified, verifiable work |
These levels need not be rigidly applied to the entire execution.
An agent may have autonomy to modify files and run local tests but need authorization to install dependencies, change schemas, or access certain services.
Limits should also consider tool capabilities.
An instruction asking the agent not to execute destructive operations does not replace technical permission mechanisms.
Whenever possible, important restrictions should be enforced by the execution environment.
Autonomy by operation
One strategy is classifying operations according to the control level needed:
- Allowed: reading code, in-scope changes, and executing authorized tests.
- Conditional: installing dependencies, changing contracts, and modifying shared resources.
- Restricted: destructive operations, access to sensitive credentials, and production modifications.
This classification should be adapted to project policies and risks.
For details on shared rules and permissions, see Standardizing projects for development with AI agents.
4. Delegation guided by objectives and constraints
Efficient delegation does not need to describe every implementation step.
The agent can receive an objective, necessary context, and boundaries within which it has autonomy to work.
This avoids micromanagement and allows it to choose how to organize execution.
However, scope must be sufficiently clear to prevent interpretations incompatible with the project.
An example delegation contract:
| Dimension | Definition |
|---|---|
| Objective | Implement an order query endpoint |
| Scope | Related services, controllers, and tests |
| Context | API contracts, authorization rules, and existing conventions |
| Autonomy | May implement, refactor local components, and run tests |
| Constraints | Do not modify shared contracts or the authentication mechanism |
| Checkpoint | Request approval if a database schema change is needed |
| Escalation | Stop upon contradictory requirements or attempts without progress |
| Completion | Requirements met, tests passed, and changes prepared for review |
This contract does not necessarily need to exist as a separate document.
Information may be distributed across the ticket, project instructions, and environment configuration.
The delegation contract defines autonomy for that task. It does not replace general project or environment permissions: authorizing changes to a module, for example, does not authorize production configuration changes. Permanent rules and technical controls remain valid even when the ticket does not repeat them.
For more on request specification, see How to create tickets in the AI era.
What matters is that the agent has access to the conditions necessary to execute work without requesting guidance for every trivial decision.
Delegating through objectives and constraints provides implementation autonomy without losing control over results.
5. Coordinating multiple agents
Parallel execution is more advantageous when activities have low dependency and can produce independent results.
A request can be distributed among agents responsible for different implementation parts while the developer coordinates contracts, dependencies, and integration.
For example:
| Agent | Responsibility | Dependency |
|---|---|---|
| Agent A | Implement services and endpoints | Defined contracts |
| Agent B | Develop interface components | API contract |
| Agent C | Prepare integration tests | Requirements and contracts |
With contracts established, some work can progress simultaneously.
However, conflicts may occur even when agents modify different files.
One agent may change shared behavior while another develops an implementation based on the previous version.
Coordination must therefore consider technical dependencies, not merely separation of directories or branches.
Avoiding excessive coordination
Not every task needs division among several agents.
Parallel execution introduces preparation, monitoring, communication, and integration costs.
If an implementation can be completed quickly by one agent, dividing it may create more work than savings.
There is also no need to permanently maintain specialized agents for every role.
Different sessions or executions can assume specific responsibilities as needed.
The choice should consider expected gains, task independence, and effort needed to integrate results.
Subtask, contract, and dependency definition is explored further in Task decomposition and delegation.
6. Checkpoints and escalation
Checkpoints allow control of important decisions without continually interrupting execution.
They should be associated with situations requiring approval, clarification, or work reassessment.
Some examples:
- Necessary shared contract changes.
- Modification of an architectural decision.
- Identification of contradictory requirements.
- Need to install unplanned dependencies.
- Potentially destructive operations.
- Successive attempts without progress.
- Discovery of an out-of-scope problem.
The agent should identify these conditions and stop or escalate the decision when necessary.
When requesting a decision, it should present the blocker and impact, evidence consulted, alternatives considered, and necessary authorization or clarification. The owner then does not need to repeat the investigation to decide how to proceed.
Example: out-of-scope change
Consider an agent responsible for implementing a frontend feature.
During execution, it identifies that the existing API does not provide a necessary field.
There are different possibilities:
1. The contract already specifies the field, but implementation has an error.
The agent can fix the problem if the change is within its permissions and authorized scope.
2. The contract does not specify the field.
The agent should flag the need for a contract change because it may affect other consumers.
3. The requirement does not clarify whether the field should exist.
Execution should request clarification before assuming a business decision.
This approach avoids both paralysis over trivial decisions and unauthorized changes to shared components.
Technical or human escalation
Not every problem needs direct escalation to the developer.
A complex investigation can be transferred to a model with greater reasoning capability or another specialized session.
However, decisions depending on authorization, business requirements, or significant scope changes continue requiring owner participation.
Escalation should consider the problem's nature, distinguishing technical limitations from decisions requiring authority.
For strategies handling unsuccessful attempts and resumption, see Failure recovery in AI agents.
7. Supervision capacity and coordination cost
The number of agents executing tasks simultaneously does not independently determine productivity.
A developer can start several parallel implementations but still needs to monitor results, resolve blockers, and integrate changes.
When executions exceed supervision capacity, review queues, pending decisions, and implementations needing rework may emerge.
Gains from code generation may be lost during integration.
For example, a developer starts five independent tasks. Four agents quickly complete their implementations, but all four results await human review. Starting more tasks at that point increases pending work without accelerating delivery.
Some factors influencing this limit:
- Task independence.
- Requirement clarity.
- Technical context quality.
- Number of shared decisions.
- Automated test coverage.
- Integration complexity.
- Developer experience.
- Reliability of agents used.
Adjusting parallelism
One strategy is gradually increasing simultaneous executions and observing delivery impact.
If agents produce results faster than they can be reviewed and integrated, adding executions tends to increase pending work.
Conversely, independent, well-documented tasks with automated validation may allow greater parallelism without constant supervision.
It is also worth assessing whether coordination cost offsets time saved.
Productivity should be measured by completed, validated deliveries, not the number of active agents or amount of generated code.
Pipeline performance indicators are covered in Observability and evaluation of development pipelines with AI agents.
8. Gradual evolution of autonomy
Agent autonomy can evolve as the project develops more reliable guidance, execution, and validation mechanisms.
An initially supervised task can become autonomous when its requirements, limits, and procedures are sufficiently defined.
This process may involve:
- Improving project instructions and documentation.
- Creating reusable automated tests.
- Standardizing contracts and interfaces.
- Defining permissions and operational limits.
- Using isolated environments.
- Implementing automatic checks.
- Analyzing previous execution results.
For example, an implementation process initially requiring many interventions can become a reusable procedure supported by instructions, tools, and tests.
This reduces supervision without relying exclusively on trust in agent behavior.
When to reduce autonomy
Evolution can also go in the opposite direction.
Recurring failures, out-of-scope changes, integration problems, or lack of reliable checks may justify additional controls.
In these cases, identifying the cause is important.
The problem may lie in instruction quality, missing context, available tools, or work complexity itself.
The solution is not always replacing the model or increasing reasoning. Often, improving execution and validation mechanisms offers more consistent results.
Autonomy should evolve with process reliability, not just model capability.
Progressive implementation of these mechanisms in a team is explored further in Gradual adoption of AI agents in software development.
Conclusion
Dividing work between humans and agents requires separating execution autonomy, decision authority, and approval responsibility.
Agents can take on complete implementations and execute different activities simultaneously, provided they have clear objectives, appropriate context, and defined operational limits.
The developer focuses attention on coordination, relevant decisions, and delivery integration, using checkpoints and escalation only when necessary.
Parallelism and autonomy should match project maturity and actual supervision capacity.
The goal is to let agents execute as much useful work as possible within reliable limits while developers retain control over decisions and results that actually require their participation.
Share this article
Sources & further reading
This note is a practical introduction, not a substitute for the original documentation. Check source dates and implementation details before making technical decisions.