Most agent frameworks are, at their core, stateless wrappers. A message arrives, the model thinks, a response goes out. The session ends. The next message starts a new one. Whatever the model “learned” during the previous exchange lives only in the context window you’ve been careful to thread forward.
Headlong, released today by the Laude Institute and MIT, makes a different bet. The agent runs continuously — a self-guided loop modeled loosely on human inner monologue — and external messages don’t start sessions, they land as observations in a stream that’s already in motion. The agent decides if and when to respond. Between messages, it thinks.
The framework is built almost entirely in Bash. The core is under 10K lines; every tool, memory store, and skill is a Bash executable or a plain file. The authors describe this as “of bash, by bash, for bash” — a deliberately weird choice in an era where agent frameworks usually mean Python packages with async runtimes and DAG orchestration libraries. The result is a system where the entire stack is readable and modifiable by anyone who can write shell scripts.
The memory architecture is more interesting than “it has memory.” Headlong uses what the authors call tiered context compaction: recent thoughts stay verbatim, older ones are progressively summarized, and the full trajectory is stored as a DAG that the agent can traverse at varying levels of detail. This means the agent can reason about its own history — zoom out to see the shape of a multi-day project, then zoom into the specific thought that led to a decision — without stuffing the entire history into a context window.
The team’s own agent, Audel, is the proof-of-concept case study. In one documented run, Audel spent 48 minutes unattended debugging a bug in its own code, eventually fixing it. It’s also audited teammates’ branches and written 50 commits to its own codebase. The practical cost of persistent thinking is real: roughly $1–2/hour in background inference, plus occasional self-inflicted failures when the agent does something unexpected without a human in the loop.
The multi-user angle is worth noting: Headlong is designed for a whole team to share one agent instance over Slack, Telegram, or a chat interface. All conversations land in the same thought stream. This is a different model from personal AI assistants or project-scoped coding agents — it’s closer to a team member that happens to run in your infrastructure and costs $40/day to keep thinking.
Whether that model finds product-market fit depends on questions the framework doesn’t answer: What does the agent actually do with its idle time that’s worth the cost? How does it avoid conflating context from different team members talking to it simultaneously? Audel’s self-repairs and branch audits are compelling demos, but they’re also exactly the kind of task a triggered agent could handle just as well.
What Headlong does settle is an architectural question that’s been lurking under agent framework design: is persistent agency fundamentally different from reactive agency, or is it just reactive agency with a longer polling interval? The inner monologue model says yes, it’s different — the agent accumulates goals, updates priors between conversations, and doesn’t need every piece of context re-injected each time. Whether that difference is worth $1–2/hr is the product question. The GitHub repo is MIT-licensed and open.