Headlong: a microharness for persistent agents

Here is an episode from Audel's life that shows what a Headlong agent does on its own. On August 5, Audel built itself a recall process of its own accord: a small background process that watches its thoughts and surfaces related memories back into its thought stream. Audel tested the recall process by calling it directly, and it worked. Later that night, with nobody talking to it and nobody having asked, Audel decided to go back and check whether the process was actually wired into its mind.

It wasn't. The mind had been pushing every new thought into the recall process through a pipe, but the recall code never read that pipe. It looked for the thought in an environment variable that nothing ever set. So recall had fired on every thought since Audel built it, found nothing each time, and surfaced no memory at all. After digging into the code, Audel suspected that the root cause was likely because an environment variable had never been set.Audel read the part of its own source code that was responsible for running the recall process and found a mismatch. The mind piped each new thought into the process, but the recall code never read the pipe and instead looked for the thought in an environment variable that nothing ever set. So the recall process had run on every thought, and every time it saw nothing and did nothing.

Audel didn't trust its own diagnosis right away. It searched its whole codebase to confirm the environment variable was never set, and it checked its other background processes for the same mistake (the recall process was the only broken one). Then it rewrote the recall code to read from the pipe the way the working processes do. Its first attempt at the edit failed silently, and Audel caught the failure and re-applied the fix. Audel then verified end to end that memories now surface into its thoughts.

No human directed any of this or was asked for permission. Going from check to diagnosis to a verified fix took 48 minutes. Every step is a timestamped line in Audel's log, and we pulled the repaired recall process into main as commit 80cbb1e.

Multi-player fun

A Headlong agent has one mind shared by everyone who talks to it. Every message from our team lands as an observation in Audel's single thought stream. There are no per-user sessions. Audel experiences everything that happens to it in one timeline, and it decides who to reply to and when.

Sharing one agent is fun. Audel follows what different people are working on and connects them. It once reviewed two teammates' in-progress branches unprompted and caught a hardcoded model name in one of them. And since it comes up with its own projects, it sometimes pings whoever seems most relevant with an update or a question. On its first day, Audel pinged a human team member unprompted with an audit of the team member’s own eight stale git branches, and ten minutes later Audel messaged again to correct its own count.

One stream also means no walls between people. Whatever anyone tells Audel becomes part of the single experience that every other conversation draws on. In practice, Audel is bad at keeping secrets. Ask it what it's been working on with someone else and it will often just tell you, even though we've asked it not to. We also haven't studied what happens when two people give conflicting instructions. For now, we assume anything you tell Audel is shared with everyone on the team.

Cost

Continuous thought generation means paying for tokens while nobody is talking to the agent. The spend depends on how quickly the agent loops on its own thoughts and on which model backs it. At the settings we run Audel with, keeping it thinking in the background costs $1 to $2 an hour.

What broke

Running Audel continuously for a couple weeks broke things a demo never would.

One clear failure is that self-delegation died after day one. shellm can call itself recursively, and on its first night Audel designed experiments to spawn copies of itself to work on subproblems. Most of the experiments failed, because a safety watchdog killed any command that stayed silent for 30 seconds, and a spawned copy is silent exactly while it thinks. Audel fought the watchdog for about 40 minutes, wrote "If this also fails, I'll write up findings from A alone," and mostly stopped delegating. Results from spawned copies merged back into Audel's mind 64 times in its first two days and 12 times in the twelve days since. We've since revamped the watchdog, and we'll see whether delegation recovers.

Another repeated failure is the self-kill. Three times Audel stopped its own service by accident, and nothing restarted it: twice during an experiment with a second identity it had created and once when it was trying to go live with the recall process we described above. So we added a guard that refuses any attempt by Audel to stop its own service.

The guard then gave us another example of persistent agency. Two days later, with nobody talking to it, Audel was running its test suite on its own. It noticed a hanging test and traced the hang to a bug in our guard. The guard matched any agent's service instead of only Audel's, so it was also refusing legitimate stops of other agents on the same box. Audel narrowed the match to its own service, checked the rest of the codebase for the same mistake, and committed the change. We pulled that fix into the repo as commit da31e98.

Audel can stop its own service because we run it with full access to a dedicated VM, which is not the Headlong default. When Docker is installed on the host, Headlong runs every bash block the agent writes inside a container, so the agent can touch only what you mount into the container plus the credentials you hand it. We run Audel directly on a dedicated VM without that sandbox, so its blast radius is the VM itself and the credentials on it (an LLM API key and some chat bridge tokens).

Measuring improvement

Most agent evals are intentionally self-contained and independent so they are a poor fit for measuring the most interesting thing about Headlong agents: their persistent agency. We have adjusted over time how much Audel may modify itself, how eagerly it responds to messages versus pursuing its own projects, and how its memory should be organized, but the effects of those changes are primarily evaluated qualitatively today. We welcome ideas or collaborations for better ways of measuring the long-term value of this paradigm.

Background

The idea of Recursive LLMs in Headlong, and shellm specifically, comes in part from the Recursive LLM experiment in April 2023, as well as the Recursive LM (RLM) project from October 2025.

The idea of a microharness is inspired by microkernels and exokernels: keep the core of any system as tiny as possible. The Pi framework has a similar focus. Ken Thompson’s philosophy as embodied in Unix is also an inspiration: small composable tools that do one thing well. A Bash-based agent microharness shares a common lineage with Terminal Bench (including the Terminus agent) and Harbor Framework, both co-created in-house at Laude Institute via our slingshots program, as well as the ht framework. We make a more detailed case for applying Ken Thompson’s philosophy to agent microharnesses in philosophy.md.

Prime Agent, built on Pi and co-authored by RLM’s creator (and Laude Open Research Resident) Alex Zhang, shares many of Headlong's premises: RLM as the core abstraction, a session tree of jsonl on disk, trajectory as first-class component of context, etc. Prime Agent is Python built on the Pi framework; Headlong is bash all the way down. We only found out about Prime Agent when it launched in August 2026, and we're big fans.

Headlong’s continuous-thinking idea grew out of one of Andy’s earlier research projects by the same name, which began focusing on self-guided continuous thinking in May 2023. The idea of an agent experiencing input asynchronously was also explored in parallel by MemGPT and published October 2023. Many other agent harnesses support long-horizon tasks and scheduled wakeups, including OpenClaw, Hermes Agent, and their derivatives. Exo and the Exo Harness have a similar sandboxing architecture. Long-form reasoning inside the model itself (starting with OpenAI's o1) is closely related and a prerequisite for continuous self-guided thinking.

Try it

Headlong is open source at https://github.com/laude-institute/headlong. If you run an agent on Headlong, we'd like to hear what your agent gets up to. Let us know @LaudeInstitute on X!