What is Loop Engineering

Loop engineering is the discipline of compiling the known path for unattended work, detecting when reality diverges from that path, and recording every skip — so the same job can be replayed without a model guessing on the happy path.

McKinsey’s State of AI keeps finding the same pattern: adoption is widespread, and operational redesign is not. Most organisations use a model somewhere. Few have redesigned how recurring work runs when nobody is watching. Loop engineering is that redesign for the boring path — the job that already has a checklist, a spreadsheet, and a named owner, but still lives in chat and memory.

Three nouns get conflated in every vendor conversation. Separate them before you compile anything:

• Eval loop — a sensor that grades a run after the fact. Did the write match the signed payload? Did the test pass? See eval loops for enterprise agent harnesses.
• Standing-order loop — a job that already exists before a run starts. A trigger admits the run; the known steps execute; a run record shows outputs and skips. See what is a standing-order loop.
• Agentic workflow — an interactive path that still reasons step by step when the route is not fully known. See what is an agentic workflow.

Loop engineering is none of those objects. It is the craft of making the known path explicit, cheap, and auditable. Harness engineering is the parallel craft for the model path: tools, hooks, and sensors around non-deterministic steps. You need both. They solve different failure modes. Compare loop engineering vs harness engineering.

What is loop engineering?

Loop engineering treats recurring operational work as something you compile, not something you re-describe every time.

Compile the known path. Take the job that already has a finish line — nightly pipeline hygiene, weekly exception report, month-end accrual list — and turn it into a fixed sequence: read these sources, apply these rules, produce these outputs, notify these people. Those are the known steps. It should not depend on someone typing “please do the usual” into a chat box.

Detect change. Reality moves. A new field appears in the CRM. A vendor changes an export format. A policy adds a threshold. Loop engineering includes sensors that notice divergence before the output lands in the wrong inbox. That is adjacent to an eval loop, but the emphasis is earlier: catch drift in the inputs and rules, not only grade the final artefact.

Record skips. When the path cannot proceed — missing file, ambiguous row, policy exception — the loop must stop, say why, and leave a record. Skips are data. A skip count trending up is how you know the compiled path is stale. Silently “doing your best” overnight is not loop engineering. That is hope.

LangChain defines Agent = Model + Harness. Loop engineering lives outside that equation on the happy path: no model invocation when the path is known. When the path is unknown, you escalate — to a person, or to an agentic workflow inside a proper enterprise agent harness. See a loop is not an agent.

Thoughtworks’ operating system for enterprise AI splits harness layers from organisational ownership. Loop engineering is the operator layer for unattended work: who owns the known steps, who gets paged on skips, how exceptions re-enter the human queue. It is not layer 1 (pick a model). It is whether Tuesday’s job is the same object as Thursday’s.

Words you’ll hear

• Known path. The fixed steps for a job you already know how to do. Not a prompt. Not “figure it out.” A sequence you can replay.
• Trigger. What admits a run: schedule, file arrival, threshold, or a deliberate manual start. See six things that start a loop.
• Skip. A deliberate halt when the path cannot proceed safely. Recorded, not hidden.
• Standing order. A loop that waits for its trigger on a workstream. The job exists before the run starts.
• Run page. One record per execution: inputs observed, steps taken, outputs attached, skips listed with reasons.
• Outputs vs actions. Outputs are artefacts (report, list, draft). Actions are writes to live systems. Loop engineering defaults to outputs first; actions need write-back governance.
• Wizard, not chat ritual. Operators start from a form with known fields, not an open-ended thread.

If a vendor uses “loop” for an eval sensor, a cron plus a prompt, or a multi-agent graph, ask which of the nouns above they actually mean. Vocabulary drift is how programmes buy the wrong control.

Why you should care

If recurring work still lives in direct messages and memory, you pay three taxes every quarter.

The reinterpretation tax. Someone re-explains the job in Slack. Someone else runs a slightly different version. Audit asks what ran last month and the answer is a person’s name.

The overnight tax. On-call gets paged. The only documentation is a clever prompt. The model guesses at ambiguous rows because nobody defined a skip.

The attribution tax. Spend and outcomes cannot be tied to a named job. McKinsey shows usage without operational redesign; loop engineering is redesign for work that should not need a meeting to start.

It affects you if:

• the same report runs every week but only one person knows the steps
• exceptions are handled in side threads with no record
• auditors ask for evidence of what ran, not what was said in chat
• you want collaborative AI on outcomes, not personal copilots on fragments

Stanford HAI’s AI Index tracks capability and deployment. Capability rises faster than operational maturity. Loop engineering is maturity for the path you already know.

NIST’s AI RMF Measure and Manage steps assume you can observe behaviour and change controls. A compiled loop with skip logs is observable. A chat thread is not.

ISO/IEC 42001 asks for documented operational controls and named actors. A standing order on a workstream with a roster beats a shared login to a consumer model.

Loop engineering vs adjacent crafts

Harness engineering. Runtime around the model: tools, hooks, eval sensors. Necessary when the step requires judgement or generation. See loop engineering vs harness engineering and what is harness engineering.

Eval loops. Grade a run. Essential on write paths and agent steps. Not the same as admitting the run. See how to evaluate loop engineering.

Workflow automation (RPA). Brittle screen replay. Loop engineering prefers API reads, explicit rules, and recorded skips over pretending the interface never changed. See loop vs RPA.

Agentic workflow. Reasoning path when the route is not fully known. Loop engineering handles the known segment; agentic workflow handles exploration. See loop vs workflow vs agent.

Chat ops. Fast for novel problems. Expensive and un-auditable for recurring ones. Multiplayer AI in a shared room is for collaboration; a loop is for repetition.

The test is simple. If a new hire can follow numbered steps and produce the same artefact, compile it. If the next step depends on reading the case, harness it. If you cannot tell which you are doing, you will agent-wrap a checklist and call it innovation.

How to do it

1. Name one recurring job with a finish line. Not “AI for finance.” “Weekly pipeline exception list for EMEA” is a job.

2. Write the path as steps a new hire could follow. If the path cannot be written, it is not ready to compile. It is still tribal knowledge.

3. Separate outputs from actions. Default to read-only connectors and artefact outputs. Promote to signed writes only with governance as a multiplayer primitive.

4. Define skips explicitly. Missing source file → skip with reason. Ambiguous owner on row 47 → skip, assign to queue. Never “best effort fill.”

5. Attach the loop to a workstream. Brief, connectors, roster, budget. See what is an AI workstream and four pillars of an enterprise AI platform.

6. Review skip rates on a cadence. Skips are product feedback. A rising skip count means the steps or the world changed.

7. Keep agents off the happy path. Agents should be disposable for exploration. The compiled loop should survive model churn.

A useful intermediate artefact is a one-page write-up of the known path: trigger, sources, rules, outputs, skip classes, named owner, named exception queue. If you cannot fill that page, you are not compiling — you are hoping a prompt will remember.

A worked example: weekly pipeline exceptions

Revenue operations runs the same exception pass every Monday: pull CRM opportunities in stale stages, join the account executive’s sheet, flag conflicts, send finance a list. Today it lives in one person’s notebook and a Slack reminder.

Compile. Step one: read CRM with agreed filters. Step two: read the sheet from the shared drive path. Step three: apply conflict rules documented in the wiki. Step four: produce a table artefact. Step five: notify finance and the regional lead on the workstream roster.

Detect change. If the sheet tab name changes, skip — do not guess. If CRM adds a required field, the sensor fires before rows silently drop.

Record skips. Row with two owners → skip row, add to human queue. Missing sheet → skip run, page on-call. Every skip appears on the run page.

No model on the happy path. If a row needs judgement (“is this deal actually committed?”), the loop escalates to a person on the roster — or to an agentic workflow if you later choose to add one for that class only. The default remains: do not guess.

This is collaborative AI for revenue operations without turning Monday into a chat ritual. Compare loops for revenue operations and collaborative AI for finance and planning when the artefact is a forecast pack.

Anthropic’s guidance on building effective agents warns against agentic complexity where a fixed pipeline suffices. Loop engineering is the operational form of that advice: use the simplest architecture that completes the job.

Research on human–AI teams (Yang et al., Nature Human Behaviour, 2022) shows performance gains when roles are clear and humans retain override. Loops encode that split: machine for the known path, human for the exception queue.

Walk the same Monday after compile. The trigger fires at 06:00. The loop reads 1,842 opportunities and 31 sheet rows. It emits 14 exceptions and 3 skips (two dual-owned rows, one missing close date). Finance opens the run page, not a forwarded screenshot. The dual-owned rows sit in a queue with a reason. Nobody re-typed “please do the usual.” That is the job, compiled.

What goes wrong

Compiling a wish. “AI for close” is not a known path. If you cannot name the sources and the finish line, you are still in discovery. Run the job manually twice and write what you actually did.

Best-effort fills. A missing owner becomes “unassigned” or a guessed name. That is an agent decision without a harness. It violates the skip rule and teaches operators that silence means success.

Chat as the compiler. A long system prompt is not a version of the known path. Prompts drift. New hires cannot start the job from a prompt they have never seen.

Eval as admission. A sensor that grades runs does not start them. You still need a standing order. See eval loops for enterprise agent harnesses.

Actions before outputs. Writing to CRM in week one hides a bad path inside live records. Prove the table against the manual baseline first. Then quote a write. See what is write-back governance.

Ownerless paths. If nobody reviews skip trends, the compiled path rots. The world changes; the steps do not; skip rates climb; people go back to Slack.

Agent-wrapping the checklist. Every Monday a model re-reads instructions and re-derives spreadsheet logic. Cost scales with repetition. Drift scales with temperature. Audit sees a transcript, not which version of the steps ran. See a loop is not an agent.

RPA theatre. Replaying clicks looks like a compiled path until the interface changes. Prefer APIs and explicit skips. See loop vs RPA.

Failure looks like a green check and a wrong list. Success looks like a skip with a reason and a human on the roster.

Governance and regulation (plain English)

Loop engineering supports controls auditors already ask for, without requiring you to become a lawyer.

Sarbanes-Oxley cares about trails for financial reporting. A compiled loop that produces a signed exception list — with skips recorded — is easier to walk than “the model said it looked fine.”

The EU AI Act and GDPR stress purpose limitation and documentation. A standing order on a scoped workstream states purpose (this job), data (these connectors), and actors (this roster). A god workspace does not.

Human-in-the-loop remains mandatory for writes and for judgement calls. Loop engineering makes the automatic segment automatic; it does not remove named signers from actions.

Regulators rarely use the phrase “loop engineering.” They ask operational questions: who decided, what ran, can you replay it. A compiled path with a run page answers those questions for unattended segments. A chat log answers them poorly.

How to start this quarter

Pick one recurring job. Not three. One.

1. Document the path as numbered steps. If step three is “ask the person who always knows,” stop — that step is a skip queue, not a step.
2. Create a workstream with the brief, read-only connectors, and the roster who cares about the output. See what is an AI workstream.
3. Implement outputs only for the first four weeks. No CRM writes. No journals.
4. Run on schedule twice alongside the legacy process. Diff the artefacts, not the vibes.
5. Add one skip rule you wish you had last month. Missing file, ambiguous row, stale tab name.
6. Review skip count in the fifth week. Update the steps or the wiki — that is loop engineering, not prompt tuning.
7. Decide whether any exception class deserves an agentic workflow. Most will not, yet.

How to evaluate loop engineering is the buying sheet: can you compile, detect, skip, and replay without opening chat?

Score any product the way you score an operations tool: same job, same output, recorded skips, named humans on exceptions. If the demo starts in a chat box, you are scoring a copilot.

How this shows up in Nimbus

The platform names a compiled standing order a Loop. It lives on a workstream: brief, connectors, roster, and governance. Operators configure the trigger and the known steps from a wizard; each execution gets a run page with outputs and skips.

Loop engineering is the practice around that object — compiling the path, defining skip classes, reviewing skip rates — not a button labelled engineering. Writes still follow write-back governance. Model steps, if you attach any, sit under harness engineering.

See what is a Nimbus Loop, loop engineering vs harness engineering, and a loop is not an agent. Product surfaces: workstreams and governance.

Related reading

• What is a Nimbus Loop
• Loop engineering vs harness engineering
• A loop is not an agent
• What is harness engineering
• What is an AI workstream

Sources

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