The trap

Every AI System Needs a Loop

The industry has been obsessed with prompts for 2 years. Bigger prompts. Structured prompts. Role-based prompts with 15 paragraphs of you are an expert.

The systems that actually work follow a different pattern. They follow a loop: Act, Observe, Evaluate, Update, Repeat. That is the only thing that matters. Not the prompt. The loop.

Prompt

Static document

A prompt is a static document. It does not recover from failure. If the model ignores line 47, nothing catches it. The output is wrong. You notice hours later.

Loop

Dynamic process

A loop is a dynamic process. The first breaks under context pressure. The second survives it. Each state has a validation gate.

A prompt does not recover from failure. A loop catches failure at every transition.

The mechanism

What the Loop Looks Like in Practice

Two loops, one architecture. Both run on the same Act→Observe→Evaluate→Update→Repeat pattern.

01

Act INGEST a raw source file, ANALYZE its entities, RECONCILE against existing pages. The first half of the loop.

02

Observe Check the validation gates. Does the page have frontmatter. Do the links work. The first feedback signal.

03

Evaluate Score the output. Pass or fail. The decision point that decides whether the loop advances.

04

Update Write the new page, log the action, bump the state file. The system now reflects the new state.

05

Repeat Next source file, or back to IDLE. The loop continues.

/extract → INGEST → ANALYZE → RECONCILE → INDEX → VALIDATE → IDLE
/post    → SESSION → STRATEGY → DRAFT → GATES → QUEUE → REVIEW? → PUBLISH → ARCHIVE → ANALYZE → IDLE

Two loops. One architecture. The Act→Observe→Evaluate→Update→Repeat pattern is the same.

The proof

Why Loops Beat Prompts

The smallest possible example of the loop pattern replacing the prompt pattern.

Prompt pattern

Hold a rule across time

NEVER create a page for passing mentions. Only create pages when a concept appears in 2+ sources. Models are bad at this.

Loop pattern

Execute a decision right now

Before creating a page: check if concept is in 2+ sources → if yes, create → if no, check if central to one source → if yes, create → if no, skip. Models are good at this.

The first is a prohibition the model must hold across time. The second is a decision tree the model executes right now. Models are bad at the first and good at the second.

The flexibility

The Human Toggle

Here is the other thing loops enable that prompts cannot: conditional human involvement.

Manual mode

Always show me

The human reviews every draft before it ships. The loop pauses at REVIEW? and waits.

Auto-threshold

Publish if quality > 0.85

The loop runs end-to-end when the gate score is high enough.

Auto-always

Zero human review

Opt-in only. The loop runs end-to-end every time. The gates are the only safety net.

A prompt cannot do this. A prompt cannot say if quality is above 0.85, proceed, otherwise pause. A prompt is static. A loop is dynamic.

The deeper shift

The Real Insight

Prompt engineering is the past. Agentic loops are the future. The people building with state machines and execution gates are shipping.

Then

Bigger prompt

Adding more rules to a static document. The model still ignores some. The system still produces silently wrong output. The team still notices hours later.

Now

State machine

200 lines of code that defines states, transitions, and validation gates. The model executes a decision tree, not a memorized rule. Every state is observable.

I absolutely wrote the big prompt first. I spent months adding rules to it. The day I replaced it with a 200-line state machine was the day the system started working. The model did not change. The architecture did.

Do not build a bigger prompt. Build a loop.

Two loops. 200 lines. 30 gates. The model did not change. The architecture did. Clone the Spiel OS repo and see for yourself.

Clone the SpielOS repo