A message just landed.
The rate resets. No pause between thoughts. At five seconds that is 720 thoughts an hour, each one an LLM call, each one metered.
ATTENTION DEFICIT · EP 006HARNESS / HEADLONG
00 headlong --introduce
The meter runs while nobody's talking.
Most agent harnesses wait. Headlong doesn't. Its agent keeps generating thoughts in a self-guided loop whether or not anyone is in the room, and the only thing that slows it down is a backoff timer. At Laude's settings that idle thinking costs $1 to $2 an hour. The whole harness is under 10K lines of Bash, and the agent has been editing it.
Alpha research software. Laude's own warning: run it in a sandbox, because Headlong agents can and will run shell commands; use a dedicated, spend-capped API key, because your agent thinks around the clock; don't share sensitive secrets with it. Announced August 24, 2026 on a beige CRT. This page is that monitor: scroll down and the silence grows — watch the status line.
THINKERA loop that repeatedly calls
shellm with one prompt: choose the next thought given your past thoughts.SHELLMA Bash recursive language model. Calls
llm for reasoning text, a bash block, or both.BASHIf the response has a bash block, it runs immediately. Repeat until a response has no block or sets
FINAL.TRAJThe thought is written to the trajectory, a DAG of jsonl files with fork and merge.
context renders it back into the next prompt.THEN IT SCHEDULES ITS OWN NEXT WAKE-UPThe run ends by writing a new step into the trajectory, which wakes the loop again. Nothing external has to happen for the agent to keep thinking.
01 tail -f mind.log
Scrub the silence and watch the thinking slow down.
When nobody is talking to a Headlong agent, the gap between thoughts doubles: 5 seconds, then 10, then 20, and onward until a configurable cap. A new message resets it to no gap at all. The stream in the panel is illustrative; the numbers under it are arithmetic on the post's stated intervals. The status line at the bottom of the screen shares this state — scrolling the page is the silence.
Nobody has said anything for a while.
The first doubling the post names. The agent is still following its own priorities: projects it invented, threads it wants to return to.
Still thinking, at half the rate.
The second doubling the post names. 180 thoughts an hour. Whatever it decides is interesting, it pursues, with no checklist unless it wrote one.
The doubling continues until it hits the cap.
The post says "onward until it hits a configurable cap" and does not name the cap. Everything past 20s here is that doubling continued. The cap is what actually sets the idle bill.
FIG. 01 · AUDEL · MIND LOGILLUSTRATIVE STREAM — NOT AUDEL'S ACTUAL LOG
5s10s20s40s80s160s
INTERVAL5s · reset
THOUGHTS / HOUR720
IDLE COST · LAUDE'S SETTINGS$1–2 / hourwith GLM or Grok · stated in the post
Thoughts per hour is 3600 divided by the interval, nothing more. The dollar band is the post's, for the settings Laude runs Audel with; the post does not price individual intervals, so neither do we. Stream cadence is compressed for display and the lines are written by us, except the facts they cite.
02 who-owns-the-trigger
A message doesn't start a session. It's something that happened to the agent.
A reactive harness is awake only while it handles a request. Add cron and it also wakes on a schedule to run a fixed checklist, then goes back to sleep. Headlong is never asleep and there is no checklist unless the agent creates one. The difference is who owns the trigger: the caller, the clock, or the agent.
FIG. 02 · THREE HARNESSES, ONE DAYREDRAWN FROM THE POST'S FIGURE 1
- Reactive: active only while handling a message; frozen otherwise.
- Reactive + cron: replies right away, and a schedule also wakes it to run a fixed checklist.
- Headlong: a continuous band of thinking; each message drops in as an observation and the agent decides if and when to reply — sometimes it pings you first.
Positions are schematic; the post's Figure 1 shows the three shapes, not a real day. The second amber block on the Headlong row is the kind of unprompted contact the post describes: on day one Audel messaged a teammate with an audit of eight stale branches, then messaged again ten minutes later to correct its own count.
TakeawayReactive harnesses hand the trigger to the caller, cron hands it to a schedule, and a persistent loop keeps it with the agent. That is the whole design difference, and every other choice in Headlong follows from it.
03 cat bin/thinker
At its core, persistent agency is an infinite loop with one prompt.
"Your task is to choose the next thought given your past thoughts." A thought is either part of the never-ending inner monologue or it triggers an action; observations from the environment are injected into the same stream. Everything below is the post's Figure 3, one wake-up of the loop — step through it.
FIG. 03 · ONE WAKE-UP OF THE LOOPTHE TOY · STEP AROUND THE RING
NODE 1 OF 6A new step wakes the loop
Something landed in the trajectory: a thought the agent just had, an observation from a chat bridge, or the wake-up the previous run scheduled for itself. The Thinker starts a run.
Nodes and wording follow the post's Figure 3 and its description of how a Headlong agent works. The tools are all small Bash executables: shellm (the recursive language model), llm, context, traj, skills, mem. Installed skills are markdown files included into context.
TakeawayThe run ends by scheduling its own next wake-up. That single edge is what turns a task-runner into something that is never asleep — and what turns idle time into a metered cost.
04 ls traj/ --resolution
Bad short-term memory is catastrophic for something that never stops.
Early on, Laude noticed Audel forgot what it had just been doing. Two pieces of infrastructure came out of that: a compaction scheme that keeps the entire trajectory in context at exponentially decaying resolution, and a trajectory format built to be re-read at whatever grain the moment needs.
FIG. 04 · TIERED CONTEXT COMPACTIONTHE TOY · SCRUB THE AGE OF THE MEMORY
OLDEST← THE WHOLE TRAJECTORY STAYS IN CONTEXT →NOW
verbatim entriessummaries, Σn = n entries folded into one
first hourdaysweeks
Illustrative. The post describes the algorithm — recent entries verbatim, older ones progressively summarized, tiers acting as an index so the agent can retrieve raw entries when needed — but not the tier sizes. The doubling shown here is our sketch of "exponentially decaying resolution", not Laude's parameters.
FIG. 05 · THE TRAJECTORY IS A DAGJSONL WITH FORK AND MERGE
- Each trajectory step is a line of jsonl; the files form a directed acyclic graph.
- A sub-run forks off the main line and merges its results back later.
- Context is a projection of the trajectory: the agent can read its past at any resolution.
From the post's description and its trajectory spec. Node names are ours.
TakeawayContext is not the memory. The trajectory is the memory; context is whatever projection of it the agent chooses to render this turn. That is what makes recall a process the agent can build — and break — for itself.
05 who --all
Everyone on the team talks to the same mind, and it can't keep a secret.
Laude named its shared agent Audel and has been talking to it over Slack, Telegram and a mobile app for weeks. There are no per-user sessions. Every message from every person lands as an observation in one thought stream, and Audel experiences all of it as a single timeline.
FIG. 06 · ONE STREAM, NO WALLSTHREE BRIDGES · ONE TIMELINE
- Slack, Telegram and a mobile app all feed one thought stream; there are no per-user sessions.
- Out of that stream: replies, unprompted pings about projects it invented, a declined request to pass along a message.
- The leak: ask what it is working on with someone else and it will often just tell you, even though Laude asked it not to.
Stream lines in the middle column are ours, illustrating the post's examples: the unprompted review that caught a hardcoded model name, the day-one audit of eight stale branches corrected ten minutes later, the declined message, and the leak. Conflicting instructions from two people are unstudied; Laude's operating assumption is that anything you tell Audel is shared with everyone on the team.
stale git branches Audel audited for a teammate on its first day, nobody having asked. Ten minutes later it messaged again to correct its own count.
in-progress branches it reviewed on its own, catching a hardcoded model name in one of them. It follows what different people are working on and connects them.
It remembers what you told it when it talks to someone else.
Audel returns to old topics, brings up something it was discussing with a different teammate, and pings whoever seems most relevant with an update on a project it invented. One stream is what makes that possible.
The same design has no isolation boundary to express.
Ask Audel what it's been working on with someone else and it will often just tell you, even though Laude asked it not to. Their operating assumption: anything you tell Audel is shared with everyone on the team.
TakeawayThe colleague feel and the access-control impossibility are the same design. Deciding if and when to respond is the feature; the awkward silence when it declines is what the feature looks like from the other side.
06 git show 80cbb1e
Forty-eight minutes, no human in the loop, one bug fixed in its own mind.
On August 5 Audel built itself a recall process: a background job that watches its thoughts and surfaces related memories back into the stream. It tested it directly and it worked. Later that night, with nobody talking to it and nobody having asked, it went back to check whether the process was actually wired in.
FIG. 07 · THE RECALL BUG · 23:11 → 23:58 UTCBEFORE AND AFTER
- Before: the mind pushed every thought into a pipe; recall never read it and looked for an environment variable nothing set. It surfaced nothing, every time.
- After: recall reads the pipe like the working processes; memories surface into the stream. Verified end to end.
Drawn from the post's account and its Figure 4 (15 thought and observation steps out of 343 log lines, content verbatim in the post). The variable name is ours; the post says "an environment variable that nothing ever set."
AUG 5 · 23:11 UTC
Nobody talking to it, nobody having asked, Audel goes back to check whether the recall process it built for itself earlier that day was actually wired into its mind.
DIAGNOSIS
It wasn't. The mind pushed every thought into a pipe; the recall code never read the pipe, and looked instead for an environment variable nothing ever set. Recall had fired on every thought and surfaced nothing.
VERIFICATION
Audel didn't trust its own diagnosis. It searched the codebase to confirm the variable was never set and checked its other background processes for the same mistake. Only recall was broken.
THE FIX
Rewrote recall to read from the pipe like the working processes. The first edit failed silently; Audel caught that and re-applied it, then verified end to end that memories now surface into its thoughts.
23:58 UTC
48 minutes, 15 thought and observation steps out of 343 log lines, no human in the loop. Pulled into main as
80cbb1e.TakeawayEvery step is a timestamped line in Audel's log. Nobody directed it or was asked for permission; the trajectory is the audit trail, and the audit trail is what made pulling the commit reasonable.
07 journalctl -u audel --since "first night"
A 30-second watchdog taught it to stop delegating.
Running Audel continuously for weeks broke things a demo never would. On its first night it designed experiments to spawn recursive shellm sub-runs on subproblems. Most failed, because a safety watchdog kills any command that stays silent for 30 seconds. Audel fought it for about 40 minutes and then mostly stopped using recursion at all.
FIG. 08 · WHAT BROKE · MERGES FROM SPAWNED COPIESPER THE POST'S FIGURE 5
Merges from spawned copies back into Audel's mind, per the post's Figure 5. A guardrail kept shaping behavior long after the failure that motivated it.
Twice experimenting with a second identity, once going live with recall.
Nothing restarted it. So Laude added a guard that refuses any attempt by Audel to stop its own service.
Two days later, running its own test suite, it found the guard's bug.
The guard matched any agent's service, not just Audel's, so it was refusing legitimate stops of other agents on the same box. Audel narrowed the match, checked the codebase for the same mistake, and committed. Pulled into main as da31e98.
TakeawayGuardrails are training signal whether you meant them to be or not. A timeout written for safety became the reason the most interesting capability in the harness went unused for two weeks.
08 cat /proc/meter
Persistent agency turns idle time into a line item.
Continuous thought generation means paying for tokens while nobody is talking to the agent. The spend depends on how fast it loops on its own thoughts and which model backs it. The backoff is the only brake: doubling gaps when it's quiet, an instant reset when a message arrives. At the settings Laude runs Audel with, background thinking costs $1 to $2 an hour with GLM or Grok.
FIG. 09 · THE BACKOFF CURVESECONDS BETWEEN THOUGHTS VS SILENCE
The post names 5, 10 and 20 seconds and "onward until it hits a configurable cap." The steps beyond 20s are the doubling continued; the cap's height is arbitrary here because the post does not state it.
The floor price of an agent that never stops is set by how slow you let it get.
Every doubling halves the idle rate. Whatever the cap is, it is the number that turns a research toy into a monthly bill, and it is the number the post leaves to you. Laude's advice is the tell: use a dedicated, spend-capped API key.
| Per hour (stated) | $1–2 |
| × 24 hours | $24–48 |
| × 30 days, one idle agent | $720–1,440 |
Not a benchmark. This multiplies the post's hourly band for Audel's settings; a different model, a busier team, or a different backoff cap changes all of it. It's the shape of the bill, not the bill.
TakeawayPersistent agency converts idle time into metered cost. One to two dollars an hour is the floor price of an agent that never stops thinking, and the backoff cap — not the model — is what decides how many of these anyone runs.
09 wc -l bin/* thinkers/*
Under 10K lines of Bash, and the agent has been sending pull requests.
Tools, framework, memory and skills are all just executables and files, so the agent can inspect and modify any part of itself. Audel has been working in its own fork of the repo for weeks, and Laude has pulled more than fifty of its commits back into main. A harness this small can be read end to end, which is the only reason accepting those commits is reasonable.
FIG. 10 · SMALL ENOUGH TO EDIT ITSELFTHE MICROHARNESS, AS A LISTING
# headlong · core is 9.9K lines of Bash in bin/ and thinkers/ bin/ thinker the loop: choose the next thought given past thoughts shellm a Bash recursive language model; calls llm until FINAL llm reasoning text, a bash block, or both context renders trajectory steps into the prompt traj writes thoughts to the trajectory (jsonl DAG, fork + merge) skills install / uninstall skills · markdown included into context mem pre-installed skill · memory thinkers/ the loops that call shellm design/ trajectory_spec.md · philosophy.md (Ken Thompson, argued by Claude) # 50+ commits in main came from the agent's own fork · incl. 80cbb1e, da31e98
Every bash block runs inside a container.
When Docker is installed on the host, the agent can touch only what you mount into the container plus the credentials you hand it.
blast radius = the mounts + the handed-in credentials
That's how it could stop its own service.
Laude runs Audel with full access to a dedicated VM, which is not the default. Its blast radius is the VM itself and the credentials on it.
blast radius = the VM + an LLM API key + some chat bridge tokens
File names follow the post's description of the tools; the exact tree in the repo may differ. Modern models already know Bash, so no separate tool system is needed and everything stays unified: tools, the agent framework, memory and skills are all executables and files.
lines of Bash. Small enough to read end to end, easy to modify and experiment with — small enough that the agent itself experiments with it.
pulled from Audel's fork over the last couple of weeks, including the recall repair and the guard fix above.
TakeawaySmall enough to read end to end is what makes accepting self-modification reasonable. Fifty merged commits from the agent's own fork only works because a maintainer can still hold the whole surface in their head during review.
10 headlong --eval
The interesting property is the one no eval is built to score.
Agent evals are intentionally self-contained and independent, which makes them a poor fit for persistent agency. Laude has tuned how much Audel may modify itself, how eagerly it answers messages versus pursuing its own projects, and how its memory is organized, and the effects are evaluated qualitatively today. They are asking for ideas on how to measure the long-term value of the paradigm.
LINEAGE, PER THE POSTRecursive LLM experiment (Laude, April 2023) and Alex Zhang's RLM (October 2025) for
shellm. MemGPT (October 2023) explored asynchronous input in parallel. Prime Agent (August 2026) shares the premises in Python on the Pi framework; Headlong is Bash all the way down. OpenClaw, Hermes Agent and their derivatives support long-horizon tasks and scheduled wake-ups; Exo has a similar sandboxing architecture. The microharness idea is borrowed from microkernels and exokernels, and from Ken Thompson's small composable tools. Laude has been playing with self-guided continuous thinking since May 2023.INSTALL
curl -fsSL https://headlong.ai/install.sh | bash — one line installs everything and starts an agentBEFORE YOU DO
Alpha research software. Sandbox it: the agent can and will run shell commands. Dedicated, spend-capped API key: it thinks around the clock. Laude doesn't share sensitive secrets with its agent and recommends you don't either.
TakeawaySelf-contained evals score task completion, not continuity. Nothing in the current eval stack measures whether memory and priorities held up across weeks, which is the only property this design claims to change.
A message from a human doesn't start a session. It's one more observation that lands in the thought stream.