A Loop Is Not an Agent

A loop is not an agent. On the normal path a loop never invokes a model. It runs a compiled recipe — read, rule, output, notify — and records skips when the world does not match. An agent reasons step by step with tools when the path is not fully known.

Anthropic’s guidance on building effective agents is explicit: do not wrap a problem in agentic machinery when a fixed pipeline will complete the job. Monday’s exception table is usually that problem. Enterprise programmes collapse the two because vendors sell “agents” and operators still need the weekly report. Collapse them and you pay twice: tokens for repetition, and incidents for guesses overnight.

Three terms, separated:

• Eval loop — sensor that grades a run after the fact. Not an agent either. See eval loops for enterprise agent harnesses.
• Standing-order loop — job on a workstream that admits a run. See what is a standing-order loop.
• Agentic workflow — interactive path that still reasons. See what is an agentic workflow.

Loop engineering compiles the known path. Harness engineering wraps the model when you truly need one. This page is the guardrail between them.

What a loop is

A loop is a standing order: trigger fires, recipe runs, run page appears, team notified. See six things that start a loop.

Properties that matter:

• Deterministic happy path. Same inputs and rules → same outputs, modulo real-world data changes you detect with sensors.
• No reinterpretation step. Nobody re-describes the job in natural language before work begins.
• Skips are first-class. Unknown vendor code → skip, not guess. Missing file → hard stop, not “try anyway.”
• Evidence by default. Run page lists inputs, recipe version, outputs, skips. Audit walks records, not transcripts.

LangChain defines Agent = Model + Harness. A loop is intentionally not that object on the happy path. It is a scheduled pipeline with operator UX: form to configure, run page to inspect, roster to notify.

Compare loop vs workflow vs agent: workflow is the abstract sequence; loop is the deployed, unattended instance; agent is the reasoning actor for unknown branches.

If you cannot show a run where the happy path invoked zero models, you do not have a loop in this sense. You have an agent on a timer.

What an agent is

An agent (in the product sense) is a model inside a harness — tools, memory, hooks, budget — choosing actions over multiple steps until a stop condition. See what is an agent harness.

Properties that matter:

• Non-determinism. Same prompt can yield different tool choices. That is feature and bug.
• Tool dispatch. The model decides which API to call based on context.
• Harness dependency. Without sensors and stops, agents claim victory early. Anthropic on long-running harnesses names premature completion as a failure mode.
• Cost scales with steps. Every reasoning turn spends tokens.

Agents should be disposable: swap models, retire experiments, keep the compiled loop. If your “loop” breaks when you change flagship, it was an agent wearing a schedule.

Agents are the right tool for exploration: a new incident, a messy inbox of unknown layout, a first draft that needs judgement. They are the wrong tool for a job two people can already perform from a checklist. Thoughtworks’ operating system for enterprise AI argues for layered harnesses. The loop is the deterministic layer. Agents sit above it, not instead of it.

Words you’ll hear

• Happy path. The route that should complete without judgement. No model.
• Unknown path. Ambiguity, missing source, novel case. Skip or escalate — do not invent.
• Skip. Recorded halt with a reason. First-class outcome.
• Escalation. Human on the roster, or an explicit agentic workflow on a named exception class.
• Scheduled prompt. Calendar plus chat. Not a loop.
• Agentic loop. Marketing merge of loop engineering vs harness engineering. Ask whether a model runs on the happy path.
• Disposable agent. The exploration branch you can retire. The standing order stays.
• Eval loop. Grades a run. Not a standing order. See eval loops for enterprise agent harnesses.

If a vendor cannot use these words without collapsing them, you will not be able to staff the exception queue.

The unknown-path rule

When the path is unknown, escalate to a person. Do not guess overnight.

Operational incidents from “helpful” automation share a shape: ambiguous input, silent default, wrong row updated, inbox quiet until finance opens the file in the morning.

Loops enforce:

1. Detect ambiguity with explicit rules.
2. Skip with a human-readable reason.
3. Notify someone on the roster.
4. Wait for a decision on the workstream — collaborative AI, not a side message.

Agents tempt the opposite: “figure it out” is in the system prompt. Overnight, nobody is there to reject the figure.

Human-in-the-loop is not a bumper sticker. It is a named person on this job for this class of exception. Loops route to that person. Agents only work if the harness refuses to act without them — see write-back governance.

Research on human–AI collaboration (Yang et al., Nature Human Behaviour, 2022) shows teams outperform when humans retain meaningful override. Loops encode override by construction; agents require harness discipline to encode it at all.

The rule is operational, not aesthetic. A model that “usually gets it” will be wrong on the night you are not watching. Skip rates are how you learn; silent accuracy is how you accumulate debt.

When vendors blur the line

Scheduled prompt. “Run this chat task every hour.” That is a scheduled agent call. No compiled recipe version. No skip semantics. No diff against last week’s baseline.

RPA with a language-model step. Screen bot plus “interpret the popup.” Fragile interface replay plus non-determinism. See loop vs RPA.

“Agentic loop”. Marketing merges loop engineering vs harness engineering. Ask: on the happy path, is a model invoked? If yes, it is not a loop in the sense of this series.

Auto-fix skips. The system “helps” by filling missing values. That is an agent decision without a harness you configured. It violates the unknown-path rule.

Eval as the product. A grading harness without a standing order still starts from chat. See eval loops for enterprise agent harnesses.

McKinsey’s State of AI reports adoption ahead of control design. Blurring loop and agent is a control design failure — interesting demo, expensive production.

Stanford HAI’s AI Index tracks agent capability rising faster than enterprise discipline. Discipline starts with naming: loop for repetition, agent for exploration.

A worked example: licence true-up

Software operations reconciles licence counts every Sunday: read the identity-provider export, read the billing export, apply entitlement rules, output a mismatch list, notify the IT lead.

As a loop (correct).

• Recipe version 2.1 configured on the workstream
• Skips: unknown SKU, duplicate email, missing billing row
• Output: table on the run page
• Zero model calls on the happy path
• IT lead works two skips Monday morning on the shared job

As an agent (incorrect for this job).

• Weekly prompt: “Compare these files and tell me what looks wrong”
• Model invents categories not in the entitlement wiki
• No skip for unknown SKU — row assigned to “misc”
• Transcript is the only artefact
• Cost every Sunday; drift every quarter

Hybrid (acceptable after the loop proves).

• Loop handles most rows with skips for edge SKUs
• Separate agentic workflow on the skip queue only: propose mapping with citations to prior approvals
• Harness: read-only history, eval sample, no write until signer
• Loop remains; agent is disposable on the branch

Walk four Sundays. Week one: 12 mismatches, 2 skips, list matches the manual spreadsheet. Week two: identity export adds a contractor flag; the loop skips those rows instead of counting them as unused seats. Week three: owner versions the recipe. Week four: skip rate returns to baseline. If week two had been a prompt, the model might have “helpfully” classified contractors as unused — and finance would have cancelled seats.

That is why loop engineering treats skips as product feedback, not as failure.

Escalation paths that work

When a loop skips, three legitimate next steps:

1. Human decision on the workstream. Default. FP&A resolves an ambiguous business unit. Controller picks a mapping. Governance as a multiplayer primitive.

2. Agentic workflow on the exception queue. Optional, scoped, harnessed. Not silent injection into the compiled recipe. See what is an agentic workflow.

3. Recipe update. If the same skip appears ten times, the world changed — update rules or wiki, version the recipe. That is loop engineering, not fine-tuning a persona.

Illegitimate next step: silent best-effort fill by a model inside the loop’s normal path.

NIST AI RMF Manage function: change controls after observed harm. Skip logs are harm sensors. “The agent tried” is not a control change.

ISO/IEC 42001 wants named actors. Escalation to “the bot” is not a named actor. Escalation to a roster role is.

What goes wrong

Hope as a skip policy. “It will probably be fine.” Overnight, probably is a write.

Transcript as evidence. Audit cannot reconstruct which rules version ran from a chat log. Recipe version on a run page can.

Irreplaceable prompt. The compiled “loop” dies when the flagship model changes. You hid a harness inside a schedule. See agents should be disposable.

Multi-agent checklist. Three models hand the same exception table between themselves. That is multi-agent theatre, not repetition.

Writes on first schedule. The clock is not a signer. See what is write-back governance.

No owner for skip trends. Skips pile up; people ignore notifications; they return to the private spreadsheet.

Eval-only programme. You can grade an agent and still have no standing order. Monday still starts in chat.

Failure looks like a green check and a wrong category. Success looks like a skip, a reason, and a person who can change the recipe.

Implications for buying and building

Ask vendors:

• Show a run where the happy path invoked zero models. If they cannot, they sell agents.
• Show a skip. If skips do not exist, they sell hope.
• Show recipe version on the run page. If only prompts version, it is an agent.
• Show escalation to a named roster member. If escalation is “try again,” it is an agent without a harness.

How to evaluate loop engineering and how to evaluate an agent harness are different scorecards. How to evaluate collaborative AI applies when humans resolve skips together.

Four pillars of an enterprise AI platform: host loops and harnesses on the same workstream; do not merge the concepts in procurement.

Regulatory readers — ISO/IEC 42001, EU AI Act, GDPR, Sarbanes-Oxley — care about accountability, not vocabulary. Loops make accountability cheap for repetitive segments: who was notified, what was skipped, what version ran. Agents can support accountability if harnessed. Unguarded agents subtract it.

Multiplayer AI and multi-agent AI: several people in the room versus several models handing work off. A loop can notify multiple people; that is not multi-agent. Adding three models to a checklist is multi-agent and usually a mistake.

Use loops for finance and planning when the output becomes a signed pack — not when you need a chatbot in the close channel.

How to start this quarter

Audit one recurring job you already automated or attempted to automate.

1. List last month’s runs. Were models invoked on every run? If yes, you likely have an agent, not a loop.
2. Find one silent default. Row filled, field inferred, email sent without skip. Remove it; add skip plus notify.
3. Re-run ten times. Happy path should show zero model steps on the run page.
4. Pick one exception class worth an agentic workflow. Attach it only to that queue with harness controls.
5. Document the unknown-path rule for the roster: unknown → skip → person. Not unknown → model → hope.
6. Review skip count after four weeks. Version the recipe or the wiki. Do not tune a persona to hide a stale rule.

If step 3 fails, re-implement as a standing order with a form, not a scheduled prompt. What is loop engineering is the practice; this page is the refusal.

How this shows up in Nimbus

A Loop on a workstream is the standing order: trigger, compiled recipe, run page. On the happy path it does not invoke a model. Skips notify the roster. Writes still require write-back governance.

If you attach an agentic workflow to a named exception class, that branch sits under harness engineering. The Loop remains; the agent stays disposable. See what is a Nimbus Loop and agents should be disposable.

Product surfaces: workstreams and governance.

Related reading

• What is a Nimbus Loop
• What is loop engineering
• Loop engineering vs harness engineering
• What is an agentic workflow
• Agents should be disposable

Sources

• LangChain, Agents
• Anthropic, Building effective agents
• Anthropic, Effective harnesses for long-running agents
• Thoughtworks, The operating system for enterprise AI
• McKinsey, The state of AI in 2025
• NIST AI RMF
• ISO/IEC 42001
• Stanford HAI, AI Index
• Yang et al., Nature Human Behaviour, 2022
• Sarbanes-Oxley Act of 2002
• EU AI Act
• GDPR