You have a brilliant colleague. Three ways to work with them: ask a question at the coffee machine, hand over a task (“come back when it’s done”), or hand over a watch (“keep an eye on this continuously, and act if needed”). Three levels of delegation — and exactly the three ways of working with an AI: chat, agent, and loop.
Everyone knows the first one. We explored the second at length in the CLI series. The third is the newcomer — and it’s the one that changes the nature of the work the most. Today we take all three apart, and above all the boundary between them. You’ll see: it’s not rocket science.
Chat: you delegate an answer
The original mode. You ask a question, the model answers, the ball is back in your court. One round trip = one human decision. You are the engine: nothing moves until you push again.
It’s the coffee machine: “how would you tackle this bug?”. The colleague answers, you go back to your keyboard. Chat touches nothing — it sheds light.
- What you delegate: an answer, an opinion, a draft.
- Who drives: you, every single turn.
- When it stops: when you stop asking questions.
And that’s perfectly fine: for learning, exploring, deciding, chat remains unbeatable. The classic trap is elsewhere — staying in chat mode for a task that deserves full delegation, and playing mail carrier: copy the error, paste the answer, copy the code, paste the next error… If you’re doing the shuttle runs, you’re ready for the next mode.
Agent: you delegate a result
The contract changes. You no longer give a question but a goal: “fix this test”, “migrate this project”. And the model enters what’s called the agentic loop: think → act (read a file, run a command, edit code) → observe the result → repeat. Until the goal is reached — or it’s stuck.
Hold on to this point, it’s the article’s lightbulb moment: an agent is already a loop. The difference with chat isn’t the model’s intelligence — it’s the same model. The difference is who pushes again: in chat, it’s you; in agent mode, it’s the loop. You saw this switch with your own eyes in Copilot’s modes — Ask stops after the answer, Agent keeps going on its own.
It’s the colleague you hand the file to: they’ll dig, try, fail, fix — and come back with the work done. You no longer approve every move, you approve the result.
- What you delegate: a result, along with the means to reach it (the tools).
- Who drives: the agentic loop, inside the frame you set.
- When it stops: when the goal is reached. The ending is natural — that’s the key point for what comes next.
Loop: you delegate a watch
And now, the newcomer. A loop is a loop around the agent: the same agent, relaunched on a schedule or on a trigger, with no natural ending. “Check the deployment every five minutes.” “Every morning, triage the overnight issues.” “Watch this PR until CI passes, and fix it if it breaks.”
The nuance fits in one sentence: the agent loops until it’s done; the loop loops because it’s never done. A deployment to watch, a CI that can break again, issues that arrive every night — there is no “done”. There is a rhythm.
It’s the on-call duty handed to the colleague: nobody asks them questions anymore, nobody gives them one-off tasks. They hold a responsibility — and they only wake you up when a call needs to be made. You step out of the inner loop and the outer loop: only the checkpoints remain.
Two nested loops, then, not to be confused:
- the inner loop (agentic): think → act → observe, until the goal;
- the outer loop (the loop): relaunch the agent at the right rhythm, indefinitely.
We brushed against the idea with delegating and automating in the CLI — the loop is its fully assumed form: AI goes from a tool you invoke to a service that runs.
A word of honesty
A loop is an agent with nobody in front of the screen — and whatever the agent gets wrong, the loop gets wrong again on every lap. Three non-negotiable guardrails:
- A stop condition and a budget. A loop with no natural ending needs an artificial one: a lap count, a token ceiling, a deadline. A loop that drifts without a budget is a bill that drifts too.
- Human checkpoints. The loop watches, proposes, prepares — but hard-to-reverse actions (merging, deploying, publishing) go through you. You delegate the watch, not the signature.
- The right tool for the right trigger. If the event is clean and reliable (a webhook, a push, an alert), a classic trigger is enough — no need to pay a model to watch the clock. The loop earns its cost when every lap requires judgment: reading ambiguous logs, sorting noise, deciding whether “this one is serious”.
And a reminder from the series: an unsupervised AI is only as reliable as its frame — evals and memory stop being optional once nobody proofreads every answer anymore.
In short
| Chat | Agent | Loop | |
|---|---|---|---|
| You delegate | an answer | a result | a watch |
| Who pushes again | you | the agentic loop | the scheduler |
| It stops | when you stop | goal reached | never (unless guardrailed) |
| Horizon | the exchange | the task | the responsibility |
| Your role | drive every turn | approve the result | set the frame, decide at checkpoints |
| Typical risk | playing mail carrier | approving too fast | drifting without a budget |
- Chat: you are the engine — perfect for understanding and deciding.
- Agent: the loop is the engine, the goal is the brake — perfect for tasks with a natural ending.
- Loop: the rhythm is the engine, the guardrail is the brake — perfect for continuous responsibilities.
- The question to ask is never “which tool is the most powerful?” but “what am I delegating: an answer, a result, or a watch?”
Next time someone sells you an “autonomous agent”, ask the awkward question: and who pushes it again? If the answer is “you”, it’s a chat in disguise. If the answer is “nobody, it just runs”, it’s a loop — and it needs a budget and checkpoints. And that, honestly… is not rocket science.
