15 posts tagged #headless.
Loop engineering's six building blocks are all context primitives wearing new names. The scheduling is cron. The part that decides whether the loop works is the context delivered on every iteration.
Decompose a reviewed spec into discrete tasks and drive it with a loop that spawns a fresh headless agent per task. Each unit of work gets a clean context window and a pass/fail gate instead of one agent compacting itself into confusion.
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. Automate only what's tested, sandboxed, and scoped.
Most AGENTS.md files defend against imagined mistakes. Mine your own transcripts, count what the agent actually gets wrong, and let the failure distribution decide what to write — and in what order.
A deterministic check on the agent's output, with one retry, kills a class of wrong answers that no prompt rewrite ever reaches — and gives you a number instead of a vibe.
Turn each reported agent failure into a committed synthetic scenario, then replay it headlessly on every change. The bug becomes a permanent guardrail instead of a one-time patch.
An unattended agent loop has no instinct for 'done.' Give it a dumb iteration ceiling it can't argue past and a completion sentinel it can raise — and it terminates correctly and cheaply.
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 the routine context work fires on its own — with your conventions already baked in.
Stop fighting the context limit with a bigger window. Write an exhaustive plan to a file, then run a relay of fresh sessions that each tick off items — so a migration too big for any single context still ships coherently.
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 headless on a schedule. One blocks regressions; the other discovers them.
Build your review as a headless command with an explicit tool allowlist, and the exact check you run by hand becomes the exact gate that runs on every pull request. One definition of 'acceptable,' two surfaces.
The blocker to running an agent overnight is never capability. It's trust. And you don't earn trust with a smarter model — you earn it with a smaller blast radius.
Treat prompts and rules like code: a golden dataset of inputs with known-good outputs, run headless on every change, gated by a hook that fails the build below baseline. The eval that blocks the merge is the one that prevents regressions.
An autonomous agent isn't a bigger context window. It's a tiny window run many times, where the git log — not the chat history — carries the decisions between passes.
Hand-passing one plan per run keeps you inside the loop doing task selection for the agent. Pipe your whole issue tracker in and let it pick the next ticket itself.