Everyone designs loops. No one asks what the agent knows each tick.
Loop engineering's six building blocks are context primitives wearing new names. The scheduling is cron; what decides the outcome is the context on each tick.
#headless
15 posts tagged #headless.
One agent drowns in a 1000-line spec. A hundred finish it by morning.
Decompose a reviewed spec into discrete tasks and spawn a fresh headless agent per task. Each unit gets a clean context window and a pass/fail gate.
Headless mode isn't a flag you set. It's a privilege you earn.
Taking the human out of the loop is the real unlock - but headless plus loose permissions plus production access is how you wake up to a wiped repo.
Stop writing rules for failures your agent never commits.
Most AGENTS.md files defend against imagined mistakes. Mine your own transcripts, count what the agent actually gets wrong, and let that decide what to write.
You can't prompt away a hallucination. You can validate it away.
A deterministic check on the agent's output, with one retry, kills a class of wrong answers no prompt rewrite reaches - and gives you a number, not a vibe.
If you can't reproduce the agent's failure, your fix is a guess.
Turn each reported agent failure into a committed synthetic scenario, then replay it headlessly on every change. The bug becomes a guardrail, not a patch.
An agent runs forever or quits one bug short. You need two brakes.
An unattended agent loop has no instinct for 'done.' Give it an iteration ceiling it can't argue past and a completion sentinel it can raise.
An Agent Gets Worse Long Before Its Context Window Fills Up
Stop fighting the context limit with a bigger window. Write an exhaustive plan to a file, then relay fresh sessions that each tick off items until it ships.
The best prompt you'll ever write is the one you delete.
An agent that waits for you to remember to ask it is a toy. Wire a deterministic event to a headless run that reads your rules, and routine work fires itself.
Run your whole eval suite on every commit and you'll stop running it.
The fix for slow, flaky agent evals isn't a faster suite - it's two loops. A cheap deterministic gate on every PR, and a slow judge suite on a schedule.
Your local review and CI gate are one check. Stop maintaining two.
Build your review as a headless command with a tool allowlist, and the check you run by hand becomes the gate on every pull request. One rule, two surfaces.
Full Autonomy Is Just a Small Blast Radius
The blocker to running an agent overnight is never capability - it's trust. And you don't earn trust with a smarter model, but with a smaller blast radius.
'It worked for me' is not a test for a non-deterministic system.
Treat prompts like code: a golden dataset run headless on every change, gated by a hook that fails the build below baseline. Only a blocking eval works.
The Loop That Re-Reads Its Diary
An autonomous agent isn't a bigger context window. It's a tiny window run many times, where the git log - not chat history - carries decisions between passes.
Your Backlog Is the Prompt
Hand-passing one plan per run keeps you inside the loop doing task selection. Pipe your whole issue tracker in and let the agent pick the next ticket itself.