Headlong is an open-source agent microharness designed for persistent agency, where AI agents maintain a continuous inner monologue rather than remaining reactive or schedule-bound. Created by the Laude Institute in collaboration with MIT researchers, it allows agents to think, plan, and execute independently, even in the absence of external user input. Unlike traditional agent frameworks that go idle after a task is completed, Headlong agents operate in an infinite loop, constantly processing observations from their environment, refining their own priorities, and generating new thoughts. This persistent nature allows for more human-like behavior, making these agents particularly effective for collaborative environments where multiple team members can interact with a shared agent.

Some of the key features are:

• Persistent Agency: Agents operate in an infinite, self-guided loop that keeps them active between human interactions.
• Recursive Language Models: Built on shellm, a Bash-based recursive language model that allows agents to decompose tasks and reason deeply.
• Microharness Design: The core is implemented in approximately 10,000 lines of Bash, adhering to Unix-like philosophy by utilizing small, composable executables.
• Team Collaboration: A shared agent model allows teams to interact with the same agent through platforms like Slack, Telegram, or custom mobile apps, fostering a shared experience.
• Trajectory Tracking: An append-only JSONL-based DAG format records all thoughts, actions, and observations, allowing for transparent introspection and debugging.
• Tiered Memory Compaction: Uses an exponentially decaying resolution strategy for memory, ensuring recent actions remain in context while older history is summarized.
• Sandboxed Execution: Includes optional Docker integration to safely run shell commands in isolated environments.
• Self-Improvement: Capable of self-modifying code through version control forked repositories and internal testing.

Operationally, a Headlong agent functions as a continuous thinker triggered by observation events. When an interaction occurs, it is injected into the thought stream as a new data point. The agent, through its shellm core, calls an LLM to generate internal thoughts and bash-based actions until a final goal is reached or a pause condition is met. The system is designed to back off exponentially in its thinking speed when idle to conserve compute costs, then ramp up instantly when new input is received. Users interact with the agent via command-line tools that mirror standard Unix utilities, making it accessible for developers comfortable with terminal-based workflows.

Some common use cases include:

• Team Assistance: Acting as a shared team member that monitors repository branches, tracks TODOs, and provides proactive status updates.
• Autonomous Research: Running independent experiments or debugging code issues on its own without needing direct human intervention.
• Continuous Monitoring: Watching internal system signals and piping observations into its inner monologue to detect anomalies or propose optimizations.
• Collaborative Knowledge Management: Serving as a central repository for team conversations and technical context, capable of cross-referencing information between different team members.