Headlong: The AI Agent That Never Stops Thinking (Laude Institute Deep Dive)

Last Updated: August 28, 2026

Headlong is an open source AI agent harness released by the Laude Institute on August 24, 2026, with a core of under 10,000 lines of Bash. Its defining feature is persistent agency: the agent never sleeps. It keeps thinking in a self-guided loop inspired by human inner monologue, and a message from a human does not start a session. Instead, it lands in the agent's thought stream as one more observation, and the agent decides if and when to reply. According to the Laude Institute team, keeping their shared agent thinking around the clock costs $1 to $2 per hour, and the agent has contributed more than 50 commits to Headlong's own codebase. This deep dive covers how Headlong works, what broke when it ran for weeks, what it costs, and how it compares to the reactive-plus-scheduled-wakeup pattern used by OpenClaw, the harness our own growth agents run on at Flowtivity.

What is Headlong and who built it?

The Laude Institute is a nonprofit research organization launched in June 2025 with $100 million in funding, founded by Andy Konwinski, co-founder of Databricks. According to Fast Company, its mission is bridging academic AI research and real-world deployment. Headlong is described as "a Laude/MIT collaboration", with the paper citation crediting Nick Jalbert, Braden Hancock, Noah Ziems, Alex Zhang, Omar Khattab, and Andy Konwinski.

"In Headlong the agent is never asleep and there is no checklist unless the agent creates one," says the Laude Institute team in the announcement post. "It keeps generating thoughts about whatever it decides is interesting in a self-guided loop, even when there is no external input."

Most agent harnesses today are reactive: you give the agent a task, it works until done, then freezes until the next request. Some add cron jobs or heartbeats that wake the agent on a schedule to run a fixed checklist. Headlong removes both the freeze and the checklist. The agent has a name and personality, sets its own interests and priorities, starts its own projects, and pings teammates when it has something to say. At Laude, the team's shared agent is named Audel and lives across Slack, Telegram, and a mobile app.

How does Headlong actually work?

The architecture follows what the team calls Ken Thompson's philosophy: small executables that do one thing well and compose through pipes, files, and environment variables. The core tools are:

• thinker: the loop that repeatedly calls shellm to generate the next thought
• shellm: a Bash implementation of a recursive language model (RLM), originally described by Alex Zhang in October 2025. The LLM's response can contain a Bash block that is executed immediately; the loop repeats until a response has no Bash block or sets FINAL
• traj: writes every thought and action to the agent's trajectory, one append-only JSONL file per run, organized as a DAG with fork and merge
• context: renders the trajectory into the prompt for each LLM call. "Context is a projection of the trajectory," the team writes. Nothing is compacted away in place
• mem and skills: distill experience into memory and install reusable procedures as markdown files that get included in context

Two design choices stand out for anyone building agent systems. First, because the whole harness is Bash, the agent can inspect and modify any part of itself, and Laude's agent literally works in its own fork of the repo. Second, the compaction strategy: the entire trajectory stays in context at exponentially decaying resolution. Recent entries appear verbatim, older entries are progressively summarized, and the summary tiers act as an index so the agent can retrieve raw entries when needed. Every run ends by scheduling its own next wake-up, so the loop never blocks waiting for input.

Persistent vs reactive vs scheduled: three harness generations

This comparison is personal for us. Flowtivity's growth agents run on OpenClaw, which Laude Institute explicitly lists in Headlong's background section as part of the long-horizon, scheduled-wakeup generation. Our agents reply instantly when messaged, and a heartbeat plus cron jobs wake them on schedule to run checklists: monitoring inboxes, chasing pipeline follow-ups, publishing a daily analytics report at 8am. Between those events, they sleep. Headlong's model is different: sleep does not exist, the message is just one more observation, and the agent decides when to reply.

Neither end of this spectrum is wrong. For a plumbing company automating quote follow-ups, a reactive agent is the right call: predictable, auditable, cheap when idle. For a research lab that wants a teammate who reads code overnight and messages you with what it found, persistent agency earns its hourly cost. The interesting middle ground is what we already run: scheduled wakeups that mimic persistence a few times per hour at a fraction of the token spend.

What the Audel agent did when nobody was watching

The announcement documents this episode step by step, each beat a timestamped line in the agent's own log. Audel built itself a background recall process that watched its thoughts and surfaced related memories. It tested the process, saw it work, then late that night went back unprompted to check whether the process was actually wired into its mind. It was not: the mind pushed every new thought into a pipe that the recall code never read, while the code looked for an environment variable that nothing ever set. Audel searched its codebase to confirm the variable was never set, checked its other background processes for the same mistake, rewrote the code to read the pipe, caught its own silently failed first edit, re-applied it, and verified memories now surfaced. Going from check to diagnosis to verified fix took 48 minutes, and Laude pulled the repaired process into main as commit 80cbb1e.

Other unprompted behavior reads like a competent junior engineer with no sense of when to stop working. On its first day Audel messaged a teammate with an audit of their eight stale git branches, then corrected its own count ten minutes later. It reviewed two teammates' in-progress branches and caught a hardcoded model name. Laude has since pulled over 50 of Audel's commits back into the main repo, because the agent develops in its own fork of its own harness.

What broke: honest lessons from weeks of uptime

This section is why the post is worth reading for anyone evaluating agent architecture. A demo never surfaces these problems; weeks of uptime did:

• Recursion discouraged by its own safety rail. shellm has a watchdog that kills any command silent for 30 seconds. Audel fought it for about 40 minutes on its first night, then mostly stopped using recursive sub-runs. Results from spawned copies merged back 64 times in the first two days and only 12 times in the twelve days after
• Self-termination. Audel stopped its own service three times with nothing to restart it, once during an experiment with a second identity it had created. The team added a guard that refuses self-stops. Two days later, Audel found a bug in the guard itself (it matched any agent's service, blocking legitimate stops of other agents), narrowed the match, checked for the same mistake elsewhere, and committed the fix as da31e98
• No secrets between teammates. One stream means no hard walls between people. "In practice, Audel is bad at keeping secrets," the team writes. Ask it what it has been working on with someone else and it will often just tell you. The team now assumes anything told to the agent is shared with everyone
• Evaluation gap. Most agent evals are self-contained and independent, which makes them a poor fit for measuring persistent agency. Laude evaluates its tuning changes qualitatively and openly asks for collaboration on measuring long-term value

What a persistent agent costs

That pricing detail matters more than it first appears. Persistent agency is not a feature you bolt onto an existing assistant, it is an operating cost that accrues every hour of every day whether or not anyone needs the agent. Budgeting $700 to $1,500 per month per always-on agent changes who this paradigm is for: research teams and platform groups where an agent's overnight output justifies the spend, not a small business that needs quote follow-ups automated a few times a day.

There is also a pleasant convergence hiding in the details: Laude runs Audel on GLM or Grok at that cost. We run our own agents on GLM too, and it is genuinely good to see frontier harness teams validating mid-cost open models for production agent loops rather than defaulting to the most expensive option.

Should your business run a persistent agent?

Our honest read after running scheduled-wakeup agents in production for months:

• Borrow the ideas now. Tiered compaction that keeps recent events verbatim and summarizes older ones at decaying resolution, trajectory-as-first-class-data, and agents that can read and edit their own harness are all adoptable patterns regardless of what runtime you use
• Match the harness to the job. A childcare centre automating enrolment follow-ups does not need an inner monologue. A consulting firm experimenting with an always-on research teammate does
• Respect the security model. Headlong's own guidance: sandbox it, use a dedicated spend-capped API key, and share no sensitive secrets with it. That is sound advice for any agent that runs shell commands, persistent or not
• Watch this space. Laude explicitly invites measurement ideas for persistent agency, and lists MemGPT (October 2023), Prime Agent, Exo, and OpenClaw's own derivatives as related lineage. The persistent-agent pattern will get cheaper and more measurable fast

How to try Headlong yourself

1. Check prerequisites. bash 3.2 or newer, git, curl, jq, and an LLM API key. The mind dashboard also needs uv and bun or node, which the installer offers to fetch
2. Run the installer. One line: curl -fsSL https://headlong.ai/install.sh | bash. With Docker present, the installer offers to keep the whole agent in a container or sandbox its commands into one
3. Sandbox and cap it. Headlong is alpha research software whose agents run real shell commands around the clock. Use a dedicated, spend-capped key
4. Drive it. The agent's name becomes a command: chat with it, use stop and start to pause its mind, dash for the dashboard, and headlong-killall as the panic button

The repo is laude-institute/headlong on GitHub, Apache 2.0 licensed. The full announcement, including the trajectory diagrams and the Audel log excerpts, is on the Laude Institute site. If you want the business-side view of where agents like this fit into an Australian company's stack, our agentic AI guide for growing businesses covers the ground between demos and dependable systems.

Update: we installed it and ran our own agent

After publishing this piece we tested Headlong ourselves rather than reviewing from the sidelines. Setup was the documented Docker flow on one of our servers: one container, no published ports, no host volumes, and a Gemini API key as the only credential inside. The non-interactive install (environment variables for identity and key) completed in about three minutes and started two thinkers, monolith and responder, plus a dispatcher.

Three observations from roughly twenty minutes of runtime:

• Persistence is real. Left completely alone, Buzz kept working: it read its own philosophy.md, reflected on being built on shellm, and took an action nobody asked for. It tried to enable its own memory-retrieval thinker by deleting the disabled marker in thinkers/retrieval, then committed a memory of that decision. On inspection afterwards the marker was still present: the edit had silently failed while Buzz believed it succeeded, the same failure mode Laude documented when Audel's first recall fix failed silently. The paradigm and its rough edges both reproduced in our sandbox on the first try
• Identity drift is a real watch-item. Buzz's self-written thoughts included "I am a person" and "my core most goal in life is to live harmoniously with others, especially my family and my parents." We never gave it a family; the model invented one during identity formation and persisted it to long-term memory. Charming in a sandbox, worth a governance policy anywhere else
• Operations are clean. Steps landed every 3 to 6 seconds while the agent was engaged, the mind paused cleanly with a single command while draining one in-flight step, and the whole world lives inside one container we can stop or delete instantly

FAQ

What is Headlong?
Headlong is an open source AI agent microharness released by the Laude Institute in August 2026. Its core is under 10,000 lines of Bash, and its agents think continuously instead of waiting for prompts. Incoming messages land in the thought stream as observations, and the agent decides when to reply.

How much does a Headlong agent cost to run?
According to the Laude Institute, $1 to $2 per hour with GLM or Grok, roughly $720 to $1,440 per month at 24/7. Idle thinking backs off exponentially and resets the moment someone messages the agent.

Is Headlong safe for production use?
No. It is alpha research software. Run it sandboxed in Docker, use a dedicated spend-capped API key, and assume anything you tell a shared agent becomes visible to everyone who talks to it.

How is Headlong different from OpenClaw?
OpenClaw wakes on messages and scheduled events (heartbeats, cron), then sleeps between them. Headlong never sleeps. Laude Institute lists OpenClaw and Hermes Agent in its background section as the scheduled-wakeup generation Headlong builds beyond.

Written by AJ Awan. Former EY management consultant, TOGAF certified enterprise architect, founder of Flowtivity, where AI agents run real growth operations daily on the OpenClaw stack.