Laude Institute shipped Headlong in August: an agent runtime written in Bash, whose agent never sleeps. The agent keeps generating thoughts between external interactions, sets its own priorities, and a human message lands as one more observation in a single stream. I maintain another entry in this design space: ai-coworkers, a tick-loop runtime where most ticks never reach the model. I cloned Headlong and read it against my own code. The two runtimes agree on almost everything except one question. What should the agent do when nothing is happening?
What Headlong does
The core loop calls an LLM with one instruction: choose the next thought given your past thoughts. A response may include a bash block, which runs immediately, and that is the entire tool system. When a run ends, it schedules its own next wake-up as a new trajectory step, so the loop never blocks on input.
Thoughts land in a trajectory stored as a DAG of jsonl files, and each call’s context is rendered from it. Older entries get summarized at exponentially decaying resolution: recent thoughts verbatim, older ones progressively compressed, with the tiers acting as a retrieval index. The recursive language model driving this, shellm, is 2,862 lines of Bash in my clone.
Their post reports the always-on loop costs $1 to $2 an hour with GLM or Grok, backing off from 5 seconds between thoughts when nobody is talking. Their agent, Audel, works in its own fork of the repo, and they have pulled over 50 of its commits into main. One night, with nobody talking to it, Audel went back to check whether a recall process it had built was wired into its mind. It wasn’t. Audel diagnosed the unwired pipe, fixed it, and verified it end to end: 48 minutes, every step a logged line, merged as commit 80cbb1e.
Same genus
Strip the framing and the two projects make the same bets. Both are daemons rather than chat: my README says there is no chat window here, and their post says a message doesn’t start a session. Both self-schedule with backoff: their idle interval doubles from 5 seconds, my tick interval doubles from a 5-minute default to a half-hour cap, and both reset on activity. Both are small runtimes meant to be forked: Headlong cites microkernels and the Pi framework, and my README cites the Pi CLI philosophy. The Bash core measured 13,838 lines across bin/ and thinkers/ when I cloned it; ai-coworkers is about 7.8k lines of TypeScript.
Both keep a thought stream a human can skim. Headlong’s is the trajectory itself; mine is stream.log and highlights.log, where 💭 lines are the coworker’s reasoning and → lines are actions. Both compress history on a schedule: their tiered summarisation, my weekly reflect ritual with event citations.
The idle question
When nothing is happening, does the agent think? In Headlong it always does, because thinking is what idle looks like. In ai-coworkers the tick has a quiet gate, ordinary code that compares the world to the last tick and returns before the LLM is invoked:
[09:06:02] alex-triage quiet — nothing new for 240s, no LLM call
[09:06:02] alex-triage idle x3 — next tick in 480sZero tokens on that tick. Sensor polling still costs API calls, nothing else does. Headlong’s idle costs their reported $1 to $2 an hour and buys initiative: the recall fix. My idle costs nothing and buys auditability: when the log says quiet, the model was not asked anything, so nothing unpredictable happened while I was away.
Three self-stops and a watchdog
Running an always-on agent for weeks broke things a demo never would, and Laude published the breakage. Audel stopped its own service three times by accident, so they added a guard that refuses self-stops. The guard then matched any agent’s service instead of only Audel’s, blocking legitimate stops of other agents on the same machine, until Audel traced a hanging test to that bug and fixed it. A 30-second silence watchdog kept killing recursive shellm sub-runs mid-thought; the agent fought it for about 40 minutes, then mostly stopped spawning sub-runs: 64 merges back into its mind in the first two days, 12 in the twelve days after.
Every one of those fixes is a bespoke commit. The equivalent classes in ai-coworkers are config, checked before the fact: BOUNDARIES.md is enforced against every tool call, writes are dry-run until a coworker is granted --live, role.audit escalates when the role files themselves drift, and tool-count plus rate caps are declared up front. Headlong’s default does sandbox: with Docker present, every bash block runs in a container. Laude runs their own instance unsandboxed on a dedicated VM, which is why self-stops were possible.
What I would take from Headlong
The memory substrate. My memory is curated: MEMORY.md is capped at 2 KB and distilled weekly, and the cap forces the coworker to decide what matters. What it loses is everything nobody thought to keep. Headlong keeps the whole trajectory at decaying resolution, which let Audel reread its own history far enough back to find the unwired recall pipe. A view like that over my events.db (SQLite with FTS5) would fit: keep the curated tiers for context, add the lossy-total view for investigations.
I expected the always-on loop to be baked into Headlong. It isn’t. thinkers/ ships pluggable variants and the design docs treat the thinker as a slot, so continuous thinking is a configuration choice sitting on a loop that could as easily be gated. The two runtimes are closer than either announcement suggests.
Where this lands
I am keeping the quiet gate. An agent that does nothing when there is nothing to do is cheap to run and boring to audit, which is why I built a tick loop. What I want from Headlong is the trajectory reader, so the next time a coworker asks itself why it stopped doing something, it can walk its own history at full resolution instead of trusting the 2 KB summary.