Autolith: A programming agent with a live runtime

TL;DR Highlight

Putting a coding agent inside one live Common Lisp image lets it edit itself and recover from crashes

Who Should Read

A backend developer building coding agents who is wrestling with long-running tasks and context-window-sized data

Core Mechanics

The whole agent is one Lisp image
- Autolith is a terminal coding agent that inspects and edits its own implementation inside a live Lisp image (a snapshot of program state in memory).
- MCP servers, memories, agendas, and LSP servers are managed in the same image.
It modifies itself at runtime
- self.redefine swaps functions, classes, and macros live without a restart.
- self.exercise verifies, self.diff reviews, self.discard drops, and self.commit saves to an internal git repo.
Crashes recover via a pristine image
- On a crash it writes a crash capsule, boots a clean recovery image, and picks a known-working generation.
- The conversation is restored and diagnosis starts in read-only mode.
RLM handles data bigger than the context
- RLM (Recursive Language Models, where the model writes small programs to split data and send pieces to sub-calls) is offered as a tool.
- A call and token ceiling is set first, and hitting it returns finished work plus a context to continue.

Community Reactions

Opinion that external tools beat self-modification
- One commenter rarely needs the agent interface itself to change.
- They argue tools solve it, and compare it to letting an agent read their Emacs config rather than run the session.
Pushback on choosing Lisp
- A commenter said agent performance depends on training data volume, so Python/JS or C/C++/Rust would be better.
- They cited danluu.com/pl-tokens.
Similar attempts and extensions
- One commenter started building something similar in Jolt (github.com/yogthos/samizdat).
- Others mentioned an actor+mailbox idea in Smalltalk or Erlang, and asked if the next step is for the agent to be the program itself.
A question on how it differs from Cursor
- No author answer is visible yet.

How to Apply

Move long command output into logs
- Trim your agent's shell tool results to a 6,000-byte preview weighted toward the tail.
- Save the full output to a file and let the agent fetch it by ID.
Use completion wake-ups instead of polling
- Hand off tasks over 10 seconds, like tests or builds, as separate jobs.
- Continue the agent turn once when they finish.
Add acceptance criteria and gates to long tasks
- Write the criteria yourself and make them immutable for the model.
- Attach deterministic gates like a test command, plus turn, token, and time limits.
Isolate parallel child work in worktrees
- Give each child its own git worktree and take back a patch plus check results.
- Have the parent check conflicts and apply them in order.

Try It

copy & run

# Paste into Claude or ChatGPT as-is. A simplified version of Autolith's mission-gate idea

You are a coding agent. Carry out the mission below under these rules.

Mission: {{task description}}

Acceptance criteria (set by me, you cannot change them):
1. {{criterion 1: e.g. all tests pass}}
2. {{criterion 2}}

Rules:
- For each criterion, first propose a command or check (a gate) to verify it.
- Finish within {{turn limit}} turns; if you cannot, summarize what is done and the state to resume from.
- Do not declare completion; only request verification. I decide pass/fail from the gate results.

First, show only the gate list and your plan.

Next to try: paste the gate results back and advance to the next turn.

Terminology

Lisp imageA snapshot of a running program's whole memory state. Like a game save file, you can store it and load it back.

REPLAn interactive console that runs what you type and shows the result. In Autolith the prompt itself is a REPL.

RLMThe model splits big material with small programs, delegates pieces to sub-calls, and collects only the answers. It is like reading a book chapter by chapter and keeping only summaries.

crash capsuleA state record written when the process dies. Like a black box, it is used to analyze the cause after recovery.

worktreeA git feature that opens multiple working folders from one repository. It keeps child agents from overwriting each other's files.