How Does Work Divide in Hybrid Teams, and How Do You Build Approval Chains?

When a department has both humans and agents, workflows do not organize themselves automatically. In How Do Agents Delegate Tasks to Each Other? we examined A2A delegation rules. In Policy and Agent State we defined each agent’s boundaries, status, and capabilities. Today we arrive at the point where these two worlds meet in the same environment: hybrid teams.

A hybrid team is not just “humans with agents beside them.” Both sides must share the same goals, have clearly defined responsibilities, and have working approval mechanisms. Otherwise, the result is chaos that differs little from shadow AI, where everyone uses their own ChatGPT for their own tasks. Role ambiguity, loss of oversight, and missing accountability become even more pronounced in complex structures that include both humans and agents.

Humans and Agents: Different Members of the Same Team

As we emphasized in What’s the Difference Between an AI Tool and an AI Agent?, the difference between a tool (a chatbot in a browser tab) and an agent (an entity with defined responsibility, model, capabilities, and policy) becomes critical here. An agent does not perform a task “however it likes”; it operates within a predefined role and policy framework.

Picture a hybrid team: an engineer uses an agent for software design while another agent tests that design. A human engineer approves the result, and an agent automatically updates the documentation. Here is how work divides:

• Human: Creative decisions, strategic priorities, final approval.
• Agent: Repetitive tasks, data collection, preliminary assessment.

But this division should not be set up as “humans do the work, agents assist.” Sometimes an agent performs preliminary evaluation, a human sets the strategic direction, and the agent implements. Sometimes a human initiates, an agent details, and the human gives final approval. What matters is that this flow is predefined and visible in the organizational chart.

If this flow is invisible, no one knows who is working for whom. When a human engineer makes a design change, it becomes unclear whether the agent should follow the old rule or the new one. This ambiguity leads to errors and loss of trust.

Approval Chain: Who Decides What?

As we stated in Why Must Your Organization Chart Include AI Agents?, every agent must have an accountable owner. The approval chain is built within this accountability framework.

The most common mistake in hybrid teams is leaving all tasks to agents or having every agent output manually approved by humans. Neither scales.

A healthy model works like this:

1. Agent performs preliminary evaluation: Collects data, produces initial output, flags risky points.
2. Human approves or corrects: Intervenes only at critical decision points.
3. Agent implements and logs: Executes approved decisions, records the process.

Every step must be recorded. Otherwise, the question “who approved what and when?” cannot be answered. Audits become impossible, errors cannot be traced, and accountability cannot be assigned.

For example, when a quality control agent marks a test result as “failed,” will a human quality manager approve this result, or will it automatically return to the production agent? This rule must be defined in the policy.md file we discussed in How Do You Set Boundaries for AI Agents?. Without a policy file, the agent does not know what to do, and the human does not know what to approve.

Config-as-Code: Managing Organizational Structure with Git

In the software world, managing infrastructure as code is a standard practice. The same idea can be applied to organizational structure. Departments, roles, agents, approval chains, and policy rules can be defined in a Markdown or YAML file.

In How Many AI Agents Are Running in Your Company, Nobody Knows? we defined shadow AI: AI usage that operates outside corporate infrastructure, leaving no trace. Config-as-code eliminates this problem entirely: organizational changes are made through PRs, providing historical review, audit trails, and rollback capabilities.

What do you gain?

• Version control: Organizational changes happen via PRs. The file history answers questions like “was this approval chain like this yesterday?”
• Review: When a new agent is added to a department or an approval chain is changed, the change is reviewed by someone else.
• Repeatability: The same structure can be quickly applied across different environments (development, test, production).
• Security: File-based structures make unauthorized changes harder and ensure all changes are recorded.

Today, many companies still manage human organizations using Excel and the memory of authorized individuals. Agents make this equation even more complex. The config-as-code approach brings both human and agent resources into the same system, increasing predictability.

Conclusion

Hybrid teams are structures where agents and humans work toward the same goal with clearly defined roles. The approval chain is visible in the organizational chart, lives in the policy file, and all changes are version-controlled.

In the seventh and final article of this week’s series, we will bring all these concepts together: why transitioning from shadow AI to structured agent organization requires more than just a tool change, and why Markdown and Git infrastructure provides the security and controllability needed.