The Nodecode project, published on Hacker News as a Show HN, proposes a different approach to building agents: it is an open-source agent on Common Lisp running on SBCL that rewrites its own code, leaving the model with exactly one tool — eval, which executes Lisp directly in the running process. Everything the agent learns lives as .lisp files under git control and survives restarts. According to the authors' report Foresight Labs FL-2026-006, on the ARC-AGI-3 benchmark, Nodecode uses significantly fewer tokens than Claude Code and Codex CLI while achieving comparable results. The project is released under the MIT license, but it lacks a sandbox, so the authors recommend isolating it in a container or virtual machine for autonomous operation.

image
image
image

What Happened

Nodecode was released to the public as a Show HN post on Hacker News, with the code available on GitHub. The core concept: the model receives only eval, which executes Lisp code inside a live SBCL process, and through it defines any missing capabilities — from read-pdf to skills, MCP connectors, and custom tools. Each definition immediately becomes functional, is saved as a separate .lisp file, committed to git, and loaded on every startup, so acquired skills are not lost after a restart. Clients — terminal, browser-based nodecode web, phone via the /link on command, and bots in Discord, Telegram, and Slack — connect to a common gateway process, where a tool written in one client is immediately available in all others. On the ARC-AGI-3 benchmark, which includes 25 public games and 183 levels, Nodecode with Claude Opus 5.5 scored 100 points, using 54% fewer tokens than Claude Code and costing 41% less; with GPT-6.1 Sol, the agent won all 25 games, using 66% fewer tokens than Codex CLI and costing 24% less. These figures are cited in the Foresight Labs FL-2026-006 report.

Context

The motivation for the project is a long-standing debate about how a model's environment should be structured. Popular CLI agents like Claude Code and Codex CLI follow a harness schema: a layer with a catalog of tools and JSON schemas is placed around the model, while memory and skills are scattered across markdown files and folders. Nodecode counters with the opposite thesis: instead of an extensible catalog, there is one expressive tool capable of defining any other, and instead of scattered memory, there is the agent's own code, which is versioned in git and executed in a live Lisp image. The measurement framework is also important: benchmarks of this kind evaluate the combination of a model with a specific environment, not the model itself, so the difference from Claude Code and Codex CLI describes the platform effect, not the superiority of one model over another. Consequently, ARC-AGI-3 becomes an arena for comparing agent environments, not just models. The project itself is still in its early stages: the repository has about 137 stars, making it more of a testable architectural experiment than a mature practice.

Why This Matters for the Industry

For the industry, there are two messages here. First: agent architecture becomes an independent lever for economics, not just a model choice; in classic harnesses, a significant portion of tokens is spent on tool descriptions and context restoration, so consolidating tool-calling into a single executable tool claims to directly reduce overhead. If the claimed effects are confirmed, companies will have a price arbitrage opportunity: the same class of tasks can be performed more cheaply by selecting the environment, without waiting for the next model. Second: if the pattern proves to be effective, expect mainstream frameworks to converge on skills as versioned code with auto-loading, a reevaluation of bloated tool catalogs, and increased demand for isolation for agents that execute code. Even as an experiment, Nodecode sets a measurable benchmark against which one can test their own agent builds.

Why This Matters for Users

Practice for the reader starts with one line: curl -fsSL https://nodecode.ai/install.sh | sh installs Nodecode on Linux, macOS, or Windows, after which you just need to connect your provider and model, including Claude Opus 5.5 or GPT-6.1 Sol. In an evening, you can verify the project's main promise: ask the agent to handle a missing operation, ensure that the created tool is saved, survives a restart, and appears in other clients — from the terminal to a Telegram bot. The price of convenience is also concrete: Nodecode has no sandbox, eval executes Lisp and shell commands with your user's permissions, so the authors advise keeping any autonomous runs in a container or virtual machine.

What Is Still Unknown / Limitations

The figures on savings come from a single source, the Foresight Labs FL-2026-006 report by the project's authors; the methodology is not disclosed in available materials, and no independent reproductions have been published. Result equality is recorded only for the pair of Claude Opus 5.5 versus Claude Code; the Codex CLI score for the GPT-6.1 Sol scenario is not provided, so one cannot attribute the same result with lower costs to the second scenario. There may also be confounding factors: the baselines may have differed in tool composition and granularity, prompts, and repetition budgets, and without controlled comparisons, it is premature to link the savings specifically to the architecture. Finally, the behavior of code that the agent wrote for itself after many cycles of self-expansion is not described in available materials.

Sources

Author

Look at AI, editorial team