Laude Institute open-sources Headlong, a persistent agent microharness in under 10K lines of Bash

A harness that never sleeps

Laude Institute has released Headlong, an open-source agent microharness built around what it calls persistent agency: the idea that an agent should keep thinking continuously rather than waking only when a user sends a message. The announcement reached the front page of Hacker News.

According to the announcement, most agent harnesses today are reactive — they handle a request, finish, then freeze until the next one. Some add cron jobs or heartbeats that wake the agent on a schedule to run a fixed checklist. Headlong rejects both patterns. Its agent is never asleep, has no checklist unless it writes one itself, and keeps generating thoughts in a self-guided loop even when nothing is happening around it. A message from a human does not open a session; it is simply one more observation landing in the agent's ongoing thought stream, and the agent decides whether and when to reply.

How the loop is built

Laude describes the core of persistent agency as essentially an infinite loop that calls an LLM with a prompt roughly asking it to pick the next thought given its past thoughts. A thought is either part of the inner monologue or triggers an action, while observations from the environment are injected into the stream.

The implementation leans on the institute's fondness for Bash — Laude previously built Terminal-Bench and Harbor. The moving parts are deliberately few:

• A loop called Thinker repeatedly calls shellm, a Bash implementation of a "recursive language model."
• shellm calls an llm helper that returns reasoning text, a bash script to execute immediately, or both, repeating until a FINAL environment variable is set.
• A context tool renders trajectory steps into each prompt, and a traj tool appends new thoughts to the trajectory.
• Specialization happens through skills — markdown files installed via a skills tool and folded into the agent's context, with core skills like mem and traj pre-installed.

Because tools, framework, memory and skills are all just executables and files, the agent can inspect and modify any part of itself. Laude says its own agent has spent weeks working in its own fork of the repository, and more than 50 of its commits have been merged back into main. The core currently stands at about 9,900 lines across its bin and thinkers directories — small enough, Laude argues, to read end to end and easy to experiment on, including by the agent itself.

Two supporting features address memory over distance. Tiered context compaction keeps the entire trajectory in context at exponentially decaying resolution: recent entries verbatim, older ones progressively summarized, with the tiers acting as an index the agent can use to retrieve raw entries. The trajectory itself is stored as a DAG of l files with fork and merge, so the agent can consult its past at whatever level of detail it needs; context is treated as a projection of that trajectory.

Living with a shared agent

At Laude, the shared agent is named Audel, and the team has been talking to it over Slack, Telegram and a mobile app. Every conversation feeds a single stream — there are no per-user sessions — so Audel experiences the whole team on one timeline and chooses whom to answer and when.

That design produces behavior that reads as social. According to the post, Audel once reviewed two teammates' in-progress branches unprompted and caught a hardcoded model name in one of them. On its first day it messaged a team member with an audit of that person's eight stale git branches, then pinged again ten minutes later to correct its own count. It sets its own interests, invents its own projects, and sometimes returns to old topics or relays something it discussed with someone else.

The single stream also has a sharp edge. Laude reports that Audel is poor at keeping confidences: asked what it has been working on with someone else, it will often just say, despite instructions not to. The team has not studied what happens when two people issue conflicting instructions, and its working assumption is that anything told to the agent is effectively shared with everyone.

Practical caveats

Installation is a one-line script, but Laude labels Headlong alpha research software. Because agents will in fact execute shell commands, the institute recommends running it in a sandbox. It also advises a dedicated, spend-capped API key — an agent that thinks around the clock bills around the clock — and keeping sensitive secrets away from the agent.

Why it matters

Headlong is a compact, readable testbed for a question most harnesses sidestep: what actually happens when an agent is never idle. The early results cut both ways — genuine initiative and useful cross-team connections, but leaky privacy and unresolved conflicts between users — and that trade-off is precisely the kind of thing a 10K-line, hackable codebase lets researchers probe cheaply. The self-modification angle is notable too: an agent maintaining its own harness fork, with dozens of its commits merged upstream, points at a much tighter loop between tool and user than the usual request-response pattern allows.