Loop Engineering Concepts › What a turn is 12 of 12 steps written
01 — part 1, conceptsconcept

What a turn is

Loop engineering is the practice of deciding how many attempts an agent gets, who makes them, and what has to be true before it is allowed to stop.

The unit

One turn is one model call by one agent. Not one iteration of your while loop, not one user request, and not one attempt: one call.

Turns are summed across every agent in the system, including the agents that never touch the work. A reviewer that reads someone else’s output and an arbitrator that settles an argument each spend turns like anybody else.

A turn is one model call. The word is borrowed from board games rather than from conversation: in a multi-agent system several participants take turns, and the count is the total across all of them.
One turn is one model call — by anybody turns worker 1 6 worker 2 1 worker 3 1 worker 4 1 reviewer 1 never touches the work arbitrator 1 0 1 2 3 4 5 6 7 8 9 10 11 one counter, six callers It does not reset when the acting agent changes. That is the whole reason four agents finishing a job can be compared with one agent finishing it. Total for this configuration: 11 turns across six agents.
The complete loop on job C, agent by agent. Four workers, a reviewer and an arbitrator, and one counter that all six of them tick.
The reviewer and the arbitrator each spend 1 turn without touching the work, out of the 11 this configuration costs. A count that omitted them would make it look cheaper than it is, and nothing would flag that.

Why the definition has to come first

Without it, four agents finishing a job look exactly like one agent finishing a job. Both “worked.” The difference is entirely in a number nobody wrote down.

This is not a pedantic point about metrics. It is the reason multi-agent systems get adopted on evidence that does not exist: the comparison that would have shown the cost was never made, because the two configurations were never put on the same scale.

what gets comparedwhat it hides
did it get the right answer?how many calls it took to get there
how long did it take?how much of that was one agent waiting for another
how many iterations of the loop?four agents inside one iteration

One place in the code, not one convention

A count that several modules maintain is a count that will eventually be wrong, and it will be wrong quietly. The rule these labs enforce is that every model call goes through one function — Team.call — and a separate check asserts the total matches the trace. A call that skipped the counter shows up as a mismatch rather than as a plausible small number.

Do this before any of the eight layers in step 3. Every one of those layers is justified by its effect on the count. If the count is soft, so is every argument you are about to make about them.

Progress, and why the raw count is not enough

A loop that takes twenty turns and finishes beats a loop that takes four and does not. So the count alone cannot rank configurations. The figure this volume ranks by is progress per turn: how much of the job got done, divided by how many calls it took. Step 4 measures it, and the result is not the one the standard advice predicts.

What to take from this step

  • One turn is one model call, by any agent, summed across all of them.
  • Reviewers and arbitrators spend turns without touching the work — 1 each, in a configuration that costs 11.
  • Route every call through one function, and assert the total against your trace.
  • Rank by progress per turn, not by turns.