Autolith debuts as a terminal coding agent with a live Lisp runtime

Autolith is a programming agent that runs in a terminal and works directly inside a repository: it reads and edits files, searches the workspace, runs commands and tests, and keeps project context, all without leaving the conversation. The current release is v0.35.0, and the binary ships with its own bundled SBCL 2.6.6 runtime, Lisp dependencies, and native helpers. It supports Linux x86-64, Linux aarch64, macOS arm64, FreeBSD x86-64, NetBSD x86-64, and OpenBSD x86-64, with glibc and musl builds for Linux; installed releases check for newer tags and ask before updating rather than updating silently. The project's own documentation calls piping a URL into a shell installer 'evil' and recommends reading the installer first or using the Nix installation path, which it describes as the better route for a fully pinned build.

Users sign in with a browser device flow or an API key across several providers: a ChatGPT Codex subscription, a Grok subscription, Fireworks AI, the Anthropic API on a pay-per-token basis, and OpenCode (zen/go); any other OpenAI-compatible endpoint can also be registered from the REPL. The default model is gpt-5.6-sol. The page showcases three captured session recordings run against v0.35.0 and driven by gpt-5.6-terra on the ChatGPT Codex subscription; the source states these are real, unedited recordings, with long real waits capped at two seconds only during playback, and each session lists its prompt, wall time, token usage, resulting artifact, and how to reproduce it.

The central design point is that the agent and its tools run in one process: Autolith is described as a terminal programming agent rather than a wrapper around a separate agent process, with its own Common Lisp image holding the provider client, terminal interface, tool registry, conversation state, persistent memories, and workspace agenda together. For context that exceeds the model's window, a mechanism called rlm.complete interns the corpus as a content-addressed object; the model itself receives only a label, size, and digest, and drives a heap-isolated Lisp environment through bounded slices, searches, and sub-inferences under an explicit call and token budget, leaving a readable inference trace for every run. Workspace search runs in-process through fff, described as a fast Rust search library, with Autolith keeping the index warm instead of starting a new search process per query; an --immutable startup mode keeps read-only inspection and recovery available while withholding evaluation, mutation, persistence, checkpoint, and rollback tools.

Autolith can also inspect and replace whole functions, methods, classes, macros, conditions, and global settings inside its own running image while it works: an exploratory change takes effect immediately and is recorded in an append-only mutation journal, where it can then be exercised, discarded, or kept. A change that is kept becomes what the source calls a private image commit, made up of a manifest and a complete, replayable Lisp script, stored in a separate private Git history so that changing the running agent does not silently patch the tracked source repository. The source describes source code, conversations, useful facts, live mutations, exact heaps, and disposable experiments as having different lifetimes that Autolith keeps separate, rather than storing everything in one database or one saved core. On the security side, the source is explicit that Autolith executes model-generated code with the user's own privileges: its process boundaries exist to protect reliability, not to defend against hostile code, so it is meant to be used as a development agent and not as a security sandbox.

Key facts

Autolith v0.35.0 is a terminal programming agent that works directly in a repository, bundling its own SBCL 2.6.6 runtime and running on Linux, macOS, FreeBSD, NetBSD, and OpenBSD, with Nix as the recommended install path.
It connects to a ChatGPT Codex subscription, a Grok subscription, Fireworks AI, the Anthropic API (pay-per-token), OpenCode (zen/go), or any other OpenAI-compatible endpoint registered from the REPL; the default model is gpt-5.6-sol.
The agent and its tools run inside a single Common Lisp image rather than as a wrapper around a separate agent process, handling the provider client, terminal UI, tool registry, conversation state, memories, and workspace agenda together.
It can inspect and redefine its own running functions, classes, and macros, journal each mutation, and turn a kept change into a private image commit with a replayable Lisp script, stored apart from the tracked source repository.
The source states Autolith executes model-generated code with the user's own privileges and is meant as a development agent, not a security sandbox, since its process boundaries protect reliability rather than defend against hostile code.

Why it matters

Most terminal coding agents are thin clients that call out to a model and shell out for tools. Autolith's pitch is different: the agent, its tool registry, and its conversation state all live inside one running Common Lisp image, and that image itself can be inspected and rewritten while the agent works, with every change journaled. Pairing that with rlm.complete, a mechanism for driving bounded searches and sub-inferences over a corpus larger than the model's context window through a content-addressed object rather than stuffing it into the prompt, positions the project around live introspection and long-context handling rather than raw benchmark performance.

Who it affects

Developers who want a terminal agent they can inspect, extend, and recover, particularly anyone comfortable with or curious about Common Lisp, since Autolith's live-mutation and image-commit workflow is built around SBCL. It also affects users of the specific providers it wires up: ChatGPT Codex, Grok, Fireworks AI, the Anthropic API, and OpenCode, plus anyone who wants to point it at a separate OpenAI-compatible endpoint.

How to use it

The binary installer supports Linux x86-64 and aarch64, macOS arm64, FreeBSD x86-64, NetBSD x86-64, and OpenBSD x86-64, with glibc and musl builds on Linux; the project recommends installing via Nix (nix run github:luciusmagn/autolith -- auth) for a fully pinned build, or building from the GitHub source with a bootstrap and check script. After authenticating with a browser device flow or an API key against a chosen provider, autolith starts the agent, which defaults to the gpt-5.6-sol model; an --immutable flag starts it in a mode that keeps inspection and recovery but disables evaluation, mutation, persistence, checkpointing, and rollback.

How solid is it

The page documents a concrete version, v0.35.0, and shows three captured sessions that the source describes as real, unedited recordings against that version, run with gpt-5.6-terra on the ChatGPT Codex subscription, with each session's prompt, wall time, token usage, and resulting artifact laid out for reproduction. The repository is hosted publicly on GitHub under the account luciusmagn. The source gives no benchmark results, adoption figures, download counts, or comparison to other programming agents, so claims about capability rest on the documented mechanism and the three sample sessions rather than on independent measurement.

Risks and caveats

The source itself warns that Autolith executes model-generated code with the user's own privileges: its process boundaries are meant to protect reliability, not to guard against hostile code, so it should be treated as a development agent rather than a security sandbox. It also flags its own binary installer as risky in the usual way, calling piping a URL into a shell 'evil' and telling users to read the installer first or prefer the Nix path instead. No pricing is stated for Autolith itself; the only cost detail given is that the Anthropic API option is pay-per-token, without a rate.