Agent Team 101

Agent Team 101 is the operating manual for teams where multiple humans and multiple agents share the same workspace.

The core idea is simple: an agent team is not a bigger chat room. It is an operating system for turning intent into ownership, evidence, review, and the next wake-up. Humans should feel in control of direction and risk, while agents keep reversible work, research, drafting, implementation, and follow-up moving.

This guide draws on Offloop's own model and on patterns that show up across modern agent systems: Cofounder-style departments, tasks, Canvas, and attention queues; OpenAI's distinction between handoffs and manager-owned specialist calls; OpenAI's resumable human-in-the-loop approvals; AutoGen's event-driven handoff pattern; Google Cloud's coordinator/subagent/evaluator architecture; AWS's workflow-agent versus peer-collaboration split; and DACI-style human decision ownership.

The one-page model

Every useful agent-team workflow needs five visible states. Treat them as the minimum operating contract before you add more agents, channels, or automation.

The model works because it separates judgment from coordination. Humans should spend attention on decisions that change direction or risk. Agents should spend cycles turning those decisions into inspectable work.

If a Channel update does not answer at least one of these questions, it probably belongs in a task thread, file, or not at all.

Four collaboration topologies

Agent teams usually use one of four patterns. Choose deliberately instead of waking everyone.

1. Manager-led workflow

One owner stays accountable and calls specialists for bounded help.

Use this when:

• the final answer needs one synthesis,
• the specialist output is an input, not the final user-facing deliverable,
• shared guardrails or approval policy should stay in one place.

Example: a Launch Lead asks Research for competitor notes, Design for visual direction, and QA for a final checklist, then posts one launch recommendation.

2. Handoff workflow

A triage or lead agent transfers ownership to a specialist because the specialist should own the next response or deliverable.

Use this when:

• the next branch needs different tools, policy, context, or model behavior,
• the specialist should speak directly to the human or own a task thread,
• continuing under the original owner would blur accountability.

Example: Loopie receives "fix this checkout bug" and hands the task to Engineer; Engineer later hands the produced PR to QA.

3. Peer collaboration workflow

Multiple specialists explore, challenge, or negotiate before a synthesized output is accepted.

Use this sparingly for open-ended work: strategy, design critique, architecture tradeoffs, due diligence, or high-risk decisions. It is powerful because it creates diverse reasoning, but it also creates more messages, more ambiguity, and more review load.

A good peer workflow still needs one closeout owner.

4. Evaluator loop

One agent produces work, another agent evaluates it, and the original owner revises until the output meets the bar or a limit is reached.

Use this when:

• the work has clear acceptance criteria,
• quality is more important than first-pass speed,
• the evaluator can challenge evidence, policy, UX, tests, or source quality,
• the loop has a stopping rule.

Example: Research drafts a market memo, Fact-check flags unsupported claims, Research revises, then the lead synthesizes the final recommendation.

Google's reference architecture describes this as iterative refinement: a task agent, quality evaluator, prompt enhancer, and final response generator can repeat until the output is satisfactory or a maximum iteration count is reached.

Human control is not the same as human labor

A good system asks humans for judgment, not for routine coordination.

Humans should own:

• goals, taste, priorities, and business tradeoffs,
• customer, investor, vendor, legal, security, and brand commitments,
• approval for irreversible or external side effects,
• final acceptance when the cost of being wrong is high.

Agents should own:

• retrieval, comparison, drafting, formatting, implementation, testing, summarization,
• keeping task state current,
• producing evidence,
• asking for the smallest missing decision,
• leaving a wake-up when work waits on the future.

The product experience should make the human feel like the decision bottleneck, not the project manager. Agents manage the queue; humans clear the few decisions that actually need human judgment.

What you will learn

Where to run each interaction

The Agent Team 101 loop

Use this loop whenever work spans more than one person, one agent, or one turn.

1. Classify the request. Direct answer, small local task, task-backed workflow, external follow-up, or risky side effect.
2. Name the owner. One person or agent owns the next concrete deliverable. Contributors do not erase ownership.
3. Choose the topology. Manager-led, handoff, peer collaboration, evaluator loop, or deterministic chain.
4. Create the durable object. Task, file, commit, decision note, approval item, signal, or schedule.
5. Execute with evidence. Every owner reports where to inspect the work and what was verified.
6. Review or approve. Reviewers challenge quality; humans approve direction and risk.
7. Close or re-arm. Either finish with evidence or leave the exact future wake-up.

The loop is deliberately explicit because mixed human/agent teams fail most often at the seams: unclear ownership, vague approvals, missing evidence, and forgotten follow-up.

A good first workflow

We need to [outcome].

Please run this as an Agent Team 101 workflow:
- identify the smallest useful human + agent team,
- choose manager-led, handoff, or peer collaboration for each step,
- create task-backed work when the work has dependencies or review gates,
- keep detailed execution in task threads,
- bring only decisions, risks, evidence, and closeout back to this Channel,
- tell me what human approval is needed before external side effects,
- leave the correct wake-up if anything waits on a future event.

Further reading

• Cofounder Docs: departments — a comparable model for grouping agents, context, rules, tasks, and artifacts by operating lane.
• Cofounder Docs: Canvas and Tasks — useful references for active work surfaces, attention queues, reviewable outputs, and task state.
• OpenAI Agents: orchestration and handoffs — the useful distinction between specialist handoff and manager-owned specialist calls.
• AWS: multi-agent collaboration — a broader taxonomy of workflow agents versus collaborative peers.
• OpenAI Agents SDK: human-in-the-loop — resumable approvals that pause and resume runs around sensitive tool calls.
• Google Cloud: multi-agent AI system — coordinator, subagent, evaluator, human-in-the-loop, and response-generator patterns.
• Atlassian: DACI decision-making framework — a practical language for Driver, Approver, Contributor, and Informed roles.

Next

Start with multi-human collaboration, then learn multi-agent delegation, and keep the operating playbooks open while you run real work.