If the word loop lost you halfway through the last agentic-hype post, you're not alone. A loop, in plain terms, is an agent run that fires without you sitting in the chat — on a schedule, or chained so step two starts when step one finishes. We're only just entering the era where that becomes normal. And it took on the order of 50 prompt iterations on code review before a 15-minute PR scan felt safe enough to run unattended here — which tells you something about the order things actually happen in.
An agentic company compounds from captured context and workflows — not from deploying orchestration sprawl on week one. The industry is on its fifth era; most teams are still catching up to the third.
Five eras — and how we got to "loop"
Most explainers skip this and jump to LangGraph diagrams. The lived path for builders looks more like this:
Era 1 was ChatGPT in a browser tab — copy-paste, cold start, no repo context. Era 2 brought AI into the IDE (Cursor is the shorthand): files and diffs in-thread, but still one problem, you watching. Era 3 is agentic CLI — Claude Code, Gemini CLI, Codex — agents that edit the codebase directly; powerful, synchronous, session-bound. Era 4 is planning first: phases, tests between phases, human review upstream in the plan. Era 5 is chain and schedule — procedures that run without you in the chat, within guardrails you had to earn.
Claude Code's own docs now reflect how fast era five arrived: /loop for session-scoped polling (watch a deploy, re-check a PR while the terminal stays open); Desktop scheduled tasks that survive restarts and can fire every minute while the app is awake; Routines on Anthropic-managed infrastructure that run when your laptop is closed — schedule, API trigger, or GitHub event. Three tiers of the same idea: less you in the thread, more procedure on autopilot.
That's what people mean by loops. Not magic. Not necessarily a hundred agents. A saved prompt plus a trigger plus enough trust that you'd accept the output without re-reading every word.
What most teams assume
The default "going agentic" story skips eras one through four and lands on the visible part: dozens of agents, orchestration graphs, a platform subscription, automate everything by Q3. Human-in-the-loop becomes a checkbox while the real question — is this procedure stable enough to run without me? — gets buried.
There's another gap nobody names cleanly: we talk about "agents" as one thing, but the shape of work in code, sales, legal, project management, and comms is not the same. There is no useful universal agent UI. What repeats is the compounding pattern: capture context → refine the procedure → decide where the human must confirm → only then chain or schedule. Code review rubrics and meeting briefs look nothing alike; the build order is identical.
Jumping from a basic subscription to complex multi-agent orchestration without that layer is how you get loops you don't trust and humans who stop reading the output.
What we built — memory before loops
The path here didn't start in era five. It started in era three mentally — one agent, memory accumulated across tasks — and only later wired the schedules.
An agent that reads those memories and suggests workflows came before any 15-minute cron: this handoff keeps costing twenty minutes; this check could run on a schedule; this looks like the code-review pattern you finally got right.
Engineering loops running today:
- Every 15 minutes, scan open PRs to staging. If present, run review workflow, then the next workflow — downstream of code review prompts refined on the order of 50 iterations across the codebase and architecture preferences.
- On a ticket, an agent analyses the ticket, then the code — again, not a generic marketplace template.
Company loops being wired next — same pattern, different domain:
- CRM (HubSpot): deal and contact context folded into what agents already know.
- Calendar: today's meetings cross-referenced with customer research — you're walking into this call; here's what matters.
- Product-side agent performance: what's failing, what deserves a ticket vs a human glance.
The blog pipeline itself follows the same arc. Many early drafts were horrible — genuinely cringe. The current strategy only landed after combining what we're building, what the market publishes, and opinions worth attaching to a name. Still iterating. This post is part of the proof.
The obvious pushback — cost, trust, and humans in the loop
I know what you're thinking: if loops are cheap, why not loop everything?
Because not everything is worth the bill — and not every procedure is stable across domains yet.
On one real agent trace from our own context work, 30 of 31 loaded tool schemas were never called, and a preload of roughly 3,000 tokens was re-injected on essentially every turn. The cheapest loop is the one you don't run until you've trimmed the overhead.
The human-in-the-loop question is procedural, and the same in code as in sales:
- Well defined — staging PR review with explicit criteria; ticket → code analysis with a checklist that survived dozens of iterations: the loop can run; you spot-check.
- Not yet defined — a new integration, a new legal wording standard, a meeting tone you're still arguing about: you stay in the loop until the procedure stops changing weekly.
Skills and workflows take a long time if you're starting fresh. That's fine. It's a reason not to pretend era five replaces the iteration that earns era four.
Worth looping now: scheduled pass/fail checks, ticket triage with a rubric you trust, meeting prep when CRM + calendar + brief template are stable, memory-driven suggestions for the next workflow candidate.
Still human-first: anything whose definition of "good" changed in the last two weeks; domains with no captured context yet; loops that would burn tokens on vague briefs; decisions where a wrong autonomous action costs more than your attention.
Where this leaves you
An agentic company isn't a demo with a hundred nodes. It's moving through the eras in order — copy-paste taught us prompts matter; in-editor and CLI taught us context matters; planning taught us procedures matter; loops only work when all three compound.
We didn't start with orchestration. We started with one agent remembering the work. The schedules came when memory made the next automation obvious — and when code review finally looked like something we'd accept from someone we'd actually hired.
The build question isn't "how many agents." It's which era you're actually in, and which procedure — in code or sales or comms — is captured well enough to run every 15 minutes without watching.
What's still on era three for you — and what's ready for era five?