How we built teams of AI agents that don't loop

A team of people has a way of working, a map of who hands work to whom, and budgets.Mode, handoff map and per-thread limits, all enforced in code.A team of agents needs more than a shared chat room.Coordination is a runtime concern, not a prompt concern.A team of people has a way of working, a map of who hands work to whom, and budgets.Mode, handoff map and per-thread limits, all enforced in code.

What happens in a product: loops, duplicate work and growing token bills.Unbounded turns, redundant tool calls and context that grows with every round.The demo belief: let the agents talk until something good comes out.Shared-transcript multi-agent chat with no routing rules.What happens in a product: loops, duplicate work and growing token bills.Unbounded turns, redundant tool calls and context that grows with every round.

The last member delivers the posts.Member 3 gets member 2's result; the lead can check the final result when that option is on.One task goes into the pipeline.The user's request starts the chain.The researcher goes first and passes its notes on.Member 1 runs; its result becomes the next member's context.The writer works from those notes, not from the whole chat.Member 2 gets the task plus member 1's result.The last member delivers the posts.Member 3 gets member 2's result; the lead can check the final result when that option is on.

The writer may hand to the editor. The editor has no arrow out, so it gets no tool at all.Targets are derived from outgoing edges; zero targets means `delegate_to` is not bound.The team, before any rules about who talks to whom.Team members as nodes of a directed graph.The lead may hand work to the researcher.Edge lead → researcher: the lead's `delegate_to` lists the researcher.And to the writer.Edge lead → writer: a second allowed target.The writer may hand to the editor. The editor has no arrow out, so it gets no tool at all.Targets are derived from outgoing edges; zero targets means `delegate_to` is not bound.

So a handoff carries the task and its context, not the transcript.`delegate_to(agent, task, context)` builds a short brief for the member.A small model has a small desk.Local models often run with a 2–4k token context window.A forwarded thread fills it quickly.Every earlier turn is added to the member's prompt.The oldest messages fall off, including the original request.Overflow truncates the earliest turns, so the member loses the goal.So a handoff carries the task and its context, not the transcript.`delegate_to(agent, task, context)` builds a short brief for the member.

The thread pauses and says why.A limit event with a reason such as "Reached N steps"; the user can continue.Lap 1: check the budget, hand off, count what was used.`check({ handoffs: 1, steps: 1 })` passes, the member runs, `count(result)` adds usage.Lap 2: same order, every time.Usage accumulates on the thread, across members.Lap 3: the check fails, so nothing runs and nothing is spent.The pre-check throws a limit error before `runMember` is called.The thread pauses and says why.A limit event with a reason such as "Reached N steps"; the user can continue.

Parallel teams are capped; otherwise members run one at a time.A counting semaphore gates member runs.Counted live, during a member's turn, not just at the end.Members report cloud tokens after each model call (`onCloudTokens`).Out of budget mid-turn? Every running member is stopped.Reaching the cloud-token limit aborts the thread's controller, so all members abort."Reached N steps", then you choose "Continue +N steps".The limit event carries a readable reason; continuing grants extra steps.You don't lose finished work because it was the last straw.The result is recorded before the post-run check.Parallel teams are capped; otherwise members run one at a time.A counting semaphore gates member runs.

Drag to compare. The merge never goes the other way.A team can tighten a member's rules, never loosen them.On its own, this agent submits forms without asking.Agent rule for the form-submit action: allow.In a careful team, it asks first.Team rules are merged as overrides at least as strict as the agent's own.Drag to compare. The merge never goes the other way.A team can tighten a member's rules, never loosen them.

You get one answer. No loop is possible.Bounded depth: recursion is ruled out by construction.You ask one agent.A normal chat turn with the writer.It asks a teammate for one part.`ask_teammate` runs the researcher headless on its own model, skills and rules.The teammate answers. It has no ask tool of its own, so it can't go deeper.Asks are one level deep: the asked agent is not given `ask_teammate`.You get one answer. No loop is possible.Bounded depth: recursion is ruled out by construction.

In the app, the real runner brings the model, skills, memory and rules.The production runner owns models, tools, memory and the browser tab group.Two halves: coordination and running one agent.Modes, map, budgets, concurrency and aborts live in the coordinator.The coordinator only calls a function to run a member.`runMember(agent, task, ctx)` is passed in, not imported.In tests, fake agents answer instantly.Unit tests drive every mode and limit without a model call.In the app, the real runner brings the model, skills, memory and rules.The production runner owns models, tools, memory and the browser tab group.

Inject the runner and test coordination without models.Dependency injection of `runMember`.A way of working: lead, pipeline or open table.Pick a coordination mode per team.A map: no allowed target means no tool.Bind `delegate_to` from the handoff graph.The task and its context, not the transcript.Short briefs keep small context windows usable.Budgets: check first, pause with a reason, keep finished work.Steps, handoffs and cloud tokens per thread.Rules only tighten in a team, and live in code.Rule merging enforced around each tool call.Inject the runner and test coordination without models.Dependency injection of `runMember`.