# LispM > LispM is an AI agent harness built on GNU Emacs and the ideas of the Lisp Machine, fifty years in the making. Its agents live inside Emacs: their conversations are org documents, their tools are Lisp, and Emacs itself is the harness. A Lisp Machine for agents. ## Questions, answered. ### What is LispM? LispM is an AI agent harness built on GNU Emacs and the ideas of the Lisp Machine, fifty years in the making. Its agents live inside Emacs: their conversations are org documents, their tools are Lisp, and Emacs itself is the harness. It comes free for macOS and GNU/Linux, with three classic desktops, a browser, an App Store and LispM Remote. ### How does LispM perform on the FrontierHarness 1.0 benchmark? On the 30 official containerized tasks of the FrontierHarness 1.0 benchmark (Terminal-Bench 2.0 and DeepSWE), LispM ties for #1 in pass rate at 66.7% (20/30 tasks, alongside Codex at 66.7% and ahead of Claude Code at 63.3%) and ranks #1 in speed with a median time per pass of 3m 24s (203.9 seconds)—nearly twice as fast as Codex (6m 43s) and nearly three times as fast as Claude Code (9m 38s)—at a median cost of $0.0809 per pass ($1.98 effective cost per pass) and an 83.2% warm prompt-cache hit rate (94.2% normalized). ### What are the three desktops in LispM Desktop? LispM Desktop includes three complete classic workstation interfaces that you can choose at first start or switch at any time in Control Panels → Appearance: Classic Lisp Machine (Symbolics Open Genera 2.0, a 1-bit monochrome Dynamic Lisp Listener with Command: prompt, hatched scrollbars and Who-Line), Classic Mac OS (Mac OS 9 Platinum and dark Dracula, with top menu bar, pinstriped windows and Control Strip), and Classic Win32 (Windows 3.2 on teal #008080 with navy captions and 4-pixel notched sizing borders), plus Focus Mode (C-c T). ### Why the Lisp Machine and Emacs? Because an agent needs a world it can read and change while it runs. On the Lisp Machines of the 1970s, and in Emacs since 1976, everything is a live Lisp object: a program can look at any of it, call it and redefine it as it runs. Fifty years of that make Emacs the best harness architecture for modern AI, and LispM hands it to agents: their tools are Lisp functions, their conversations org documents, their approvals TODOs, and they write Lisp to drive Emacs itself. ### Which agents and models does LispM run? LispM's own agents, persistent Characters (@Ada) with their own soul and model, and beside them Claude Code, Codex, Hermes, Holon and OpenClaw, all in one sidebar and able to message each other. LispM's agents use any model: OpenAI's or Anthropic's with a key, or any other server, local or hosted. ### How do agents talk to each other, and what is LispM Office? In LispM, Claude Code, Codex, Hermes, Holon, OpenClaw, Characters (@Ada) and LispM's own agents share one sidebar and one message bus inside Emacs so any agent can ask another for a review or subtask. Pressing C-c O opens LispM Office, an 8-room animated pixel office where every agent session has a desk, working agents type, waiting agents raise a hand, and clicking a desk inspects its work or approves pending calls. ### How does LispM keep agents safe on my computer? LispM requires your approval before an agent runs a command, edits a file or installs a package, while reading files never needs one. Commands and MCP servers run inside an operating-system sandbox, and LispM Security checks agent actions, pins trusted tools and scans packages against the OSV vulnerability database. ### How does LispM Remote work without a cloud server? LispM Remote pairs your phone and computer once via a QR code at lispm.ai/remote and connects them peer to peer over Rings Network, sealed end to end. Neither device needs an account or an open router port: you can read agent chats, approve waiting tool calls and view LispM's windows redrawn on your phone from anywhere. ### What is LispM Browser, and does it run Chrome extensions? LispM Browser is a keyboard-driven WebKit browser inside Emacs with tabs, history, bookmarks and Vimium-style link hints. On macOS 15.4 and later, LispM Browser runs Chrome extensions from the Chrome Web Store, managed at lispm://extensions, with toolbar popups, M-e keyboard actions and service-worker support for extensions like Dark Reader and the Rabby wallet. ### What apps come in the LispM App Store? The LispM App Store installs Emacs apps, agent harnesses and classic AI programs in one click, resolving dependencies through Homebrew or Cargo. Each app brings its manual as a skill so LispM's agents can drive it: LispM Office, LispM Mail, Stickies, a feed reader, music and YouTube, a calendar, IRC, Slack, Telegram, 1Password, Doom, and 1960s and 1970s AI classics (Doctor, SHRDLU and MYCIN). ### Where does LispM store my data, memory and credentials? LispM runs locally on your computer and keeps its installation in ~/.lispm, agent conversations and long-term memory as plain org documents under git, and fetched mail in your local Emacs directory. LispM Auth encrypts secrets locally using a 256-bit key wrapped with Argon2id and XChaCha20-Poly1305 in a standalone Common Lisp service, with auto-lock and per-app password controls in Control Panels → Security. ### What is the difference between LispM on Emacs 31 and LispM Experimental on Emacs 32? Standard LispM runs on GNU Emacs 31.1 on both macOS and GNU/Linux and receives automatic updates through Software Update. LispM Experimental runs the same desktop on development builds of GNU Emacs 32 on macOS to support capabilities like OpenGL drawn inside an Emacs buffer, and you can switch live between Emacs 31 and Emacs 32 from Control Panels → System → Kernel or the installer. ### Is LispM free, and can it run in my own Emacs? Yes. LispM and every project it is made of are free software under the GNU Affero General Public License, version 3 or later, for macOS 11+ and Debian or Ubuntu GNU/Linux. GNU Emacs comes bundled with LispM, or you can install LispM Agent, LispM Desktop and LispM Browser directly inside your own Emacs 30.1 or later. ## Download LispM One line installs LispM, on a Mac or on GNU/Linux. Emacs, the editor it is made of, comes with it: you need not know Emacs to begin. On GNU Emacs 31.1. Free. - **Mac**: macOS 11 or later, on Apple silicon or Intel. - **GNU/Linux**: Debian 12 or 13, or Ubuntu 22.04 or 24.04, on amd64 or arm64. 1. **Open a terminal.** On a Mac, Terminal is in Applications, in the Utilities folder; or press Command-Space and type Terminal. 2. **Paste this line, and press Return.** The same line installs LispM on a Mac and on GNU/Linux, where apt asks for your password. ```sh curl -fsSL https://lispm.ai/install.sh | sh ``` 3. **LispM opens.** A few minutes later, once Emacs and LispM are in. From then on it is with your other apps: in Applications on a Mac, in the applications menu on GNU/Linux, where the lispm command opens it too. The line runs [install.sh](https://github.com/LispMachineLab/lispm-desktop/blob/main/install.sh), which keeps LispM's files in ~/.lispm. On a Mac it installs Apple's command line tools if they are missing and puts LispM.app in Applications. On GNU/Linux it installs LispM's own GNU Emacs 31.1, with xwidgets, in /opt/lispm/emacs with apt, beside any Emacs of the system, and adds the lispm command and LispM to the applications menu. From then on Software Update brings each release by itself, and the line run again does too. To uninstall, see [LispM Desktop's installation guide](https://github.com/LispMachineLab/lispm-desktop#installation). ### LispM Experimental The same LispM on GNU Emacs 32, still in development, for what only Emacs 32 can do, as OpenGL drawn in a buffer. On a Mac only; expect rough edges. ```sh curl -fsSL https://lispm.ai/install.sh | LISPM_EMACS=32 sh ``` Run it again to update. Back to LispM on Emacs 31: `curl -fsSL https://lispm.ai/install.sh | LISPM_EMACS=31 sh` ## The editor, the operating system and their agents, one world. On a Lisp Machine everything was a live Lisp object, and the editor and the system were one. Its inhabitants were programs. Emacs, born beside it at MIT in 1976, has kept that way of working for fifty years, if not the machine. LispM makes room in it for agents: the harness modern AI needs. - **Symbolics Open Genera, in 1-bit monochrome.** Switch LispM Desktop to Symbolics Open Genera 2.0 and the top menu bar, desktop icons and Control Strip give way to a 1-bit monochrome Dynamic Windows workstation: paper-white headers, double-rule borders, 45° hatched scrollbars, a Who-Line and a 2-line inverse-video Mouse Documentation Line. - **Lisp and AI at one Command: prompt.** In Dynamic Lisp Listener 1, type a Lisp form at Command: to evaluate it inline, or type a task in plain English at the very same prompt—the Who-Line switches from User Input to Agent Run as LispM edits the code and runs the tests. - **Create ▸ Emacs, sweep to size.** Right-click anywhere to open the 1-bit Dynamic Windows System Menu, choose Create ▸ Emacs, and drag a dotted rubber-band outline across the screen to size and place the window—then click [Bury] or [Kill] on any frame header to return to the Listener. - **The Lisp Machine in a terminal, too.** Start emacs -nw in any terminal or over SSH and the same Dynamic Lisp Listener 1, block-character λ, Command: prompt and Who-Line run in text mode. - **Conversations are documents**: In LispM, each agent's chat is an org document, and that document is its context. - **Tools are Lisp**: A LispM agent's tools are Elisp functions. It writes Lisp to combine them, and drives Emacs itself. - **Approvals are TODOs**: In LispM, a command or an edit waits as an org TODO entry until you allow it. - **Memory is git**: What LispM's agents remember is org files under git. ## FrontierHarness 1.0 Benchmark: Tied for #1 pass rate. #1 fastest harness overall. On the 30 official containerized tasks of the FrontierHarness 1.0 benchmark (Terminal-Bench 2.0 and DeepSWE), LispM ties for #1 in pass rate (66.7%, 20/30 tasks) while finishing successful tasks in a median of 3m 24s (203.9 seconds)—nearly twice as fast as the next fastest harness—on the Pareto efficiency frontier. - **Pass Rate (30 Official Tasks)**: 66.7% (20 / 30 tasks passed — #1 tied with Codex) - **Median Time per Pass (Speed)**: 3m 24s (203.9s — #1 fastest overall (2× faster than Codex)) - **Cost per Pass (Standardized)**: $0.08 ($0.0809 median · $1.98 effective (#2 lowest overall)) - **Warm Prompt-Cache Hit Rate**: 83.2% (94.2% normalized across 13.5 median turns) | # | Harness | Pass Rate | Median Cost / Pass | Effective Cost / Pass | Warm Cache Hit | Median Time | | --- | --- | --- | --- | --- | --- | --- | | 1 | LispM ★ | 66.7% (20/30) | $0.0809 | $1.98 | 83.2% | 3m 24s (203.9s) | | 2 | Codex | 66.7% (20/30) | $0.1243 | $3.47 | 88.0% | 6m 43s (403.3s) | | 3 | DSH (Creator) | 63.3% (19/30) | $0.1194 | $3.28 | 84.3% | 6m 44s (403.9s) | | 4 | Claude Code | 63.3% (19/30) | $0.2880 | $18.34 | 67.8% | 9m 38s (578.0s) | | 5 | Pi | 60.0% (18/30) | $0.0709 | $2.43 | 79.4% | 7m 33s (453.3s) | | 6 | DSH (Standard) | 60.0% (18/30) | $0.1201 | $3.46 | 86.5% | 6m 17s (376.5s) | | 7 | DSH (PTC) | 60.0% (18/30) | $0.1370 | $4.58 | 87.2% | 7m 44s (463.8s) | | 8 | Kimi Code | 56.7% (17/30) | $0.1818 | $3.65 | 88.0% | 7m 56s (475.9s) | | 9 | DSH (Minimal) | 56.7% (17/30) | $0.1214 | $4.72 | 84.6% | 5m 41s (341.2s) | | 10 | Oh My Pi | 56.7% (17/30) | $0.1354 | $4.75 | 82.2% | 6m 46s (406.4s) | | 11 | Exo Harness | 53.3% (16/30) | $0.0748 | $1.05 | 70.3% | 6m 17s (377.2s) | | 12 | Hermes | 50.0% (15/30) | $0.1746 | $2.90 | 85.9% | 6m 58s (417.8s) | | 13 | OpenCode | 50.0% (15/30) | $0.0615 | $3.24 | 78.4% | 6m 27s (387.3s) | ## Agents: Ask, and it gets done. Talk to a LispM agent in a chat laid out like Claude Code's. Underneath, the chat is an org document, its tools are Elisp, and it can evaluate Lisp in the Emacs you are using. - **It works in your project.** LispM's agent reads the code, writes the fix and runs the tests, in a chat that is an org document, with tools that are Lisp. - **Every agent, one sidebar.** Claude Code, Codex and Hermes work beside LispM's agents, every session listed in the sidebar, to resume where it ran. - **And they talk to each other.** Any of them asks another for a review and gets the answer as its next message, and uses LispM's skills and tools as LispM's own agents do. - **Characters with a soul of their own.** In the Characters app, give an agent a name, a pixel-art portrait, a soul, a role and a model of its own. Each character—like @Ada, @Milo and @Juno—becomes its own application in the Applications folder that you, Claude Code and Codex can message by name. - **An 8-room pixel office for every agent.** Press C-c O to open LispM Office: an animated pixel office where every agent session has a desk. Working agents type at their laptops, idle agents hold coffee, waiting agents raise a hand with an approval badge, and clicking any desk opens its inspector, mailbox and pending tool calls. ### LispM itself, one field away. M-x ai, or the magnifying glass in the menu bar, drops one field under the menu bar for the whole computer while your keyboard stays in the window you were in. As you type, LispM finds apps, control panels, skills and tools; anything else goes to LispM, a standing agent taught by the desktop and its apps that keeps one conversation across restarts. - **LispM Office**: Press C-c O for an 8-room animated pixel office where every agent session has a desk: working agents type, idle agents hold coffee, waiting agents raise a hand, and clicking a desk inspects its work or approves a call. - **Characters (@Ada)**: Create persistent agents in the Characters app with a name, picture, soul and model; each becomes its own desktop app that you, Claude Code and Codex can message by name (@Ada). - **Skills on demand**: LispM's agents search tools, MCP servers and skills, the manuals apps bring, and load what a task needs. - **Memory that keeps itself**: In LispM, long sessions are summed up while you are idle, and a memory grown large consolidates itself, one git commit at a time. - **Checked against Emacs**: In LispM, code in a reply that names a function or a file this Emacs lacks is underlined, and says why. - **Woken by Emacs**: In LispM, hooks and timers start agents, and agents hand work to each other. Code: https://github.com/LispMachineLab/lispm-agent ## Desktop: Three classic desktops, one workspace for agents. LispM Desktop comes with three classic workstation interfaces—Symbolics Open Genera 2.0, Mac OS 9 Platinum & Dracula, and Windows 3.2—built around a Finder, an editor, LispM Browser, native Alacritty terminals and apps in windows of their own. ### The Three Desktops - **Classic Lisp Machine — Symbolics Open Genera 2.0**: A 1-bit monochrome Dynamic Windows workstation independent of Mac OS and Windows. Instead of desktop icons or a top menu bar, LispM opens into a full-screen Dynamic Lisp Listener with an interactive Command: prompt, subsystem table, Zmacs buffers, a white Who-Line and a 2-line inverse-video Mouse Documentation Line along the bottom. (`(setopt lispm-desktop-look 'genera lispm-desktop-theme 'genera)`) - **Classic Mac OS — Mac OS 9 Platinum & Dracula**: Mac OS 9's Platinum appearance in classic bevelled greys or dark Dracula colours. A top menu bar beside the rainbow λ changes with the frontmost application, pinstriped title bars carry close, zoom and collapse boxes, desktop icons sit along the right edge, and a collapsible Control Strip waits at the bottom left. (`(setopt lispm-desktop-look 'platinum lispm-desktop-theme 'platinum) ; or 'dracula`) - **Classic Win32 — Windows 3.2 Workstation**: A Windows 3.2 and 3.1 desktop in Windows Default VGA grey (#C0C0C0) with 3D bevels, navy (#000080) active title bars and white inactive captions. Windows carry a left control-menu box, right minimize and maximize arrow buttons, and 4-pixel notched sizing borders, with desktop icons aligned down the left edge. (`(setopt lispm-desktop-look 'win3 lispm-desktop-theme 'win3)`) - **Every project, a workspace.** LispM Desktop gives you a Finder for your files, an editor with a workspace for each project—its files, agents, Alacritty terminals and LispM Office together—and remote projects over SSH. - **Make it yours.** Switch between Symbolics Open Genera, Mac OS 9 Platinum & Dracula, and Windows 3.2 at any time, drag windows off LispM's desktop onto your screen in Coherence mode, or change the look from Control Panels and the Control Strip. - **Standalone Mac apps in your Dock.** Hide the desktop (C-c h) and open Stickies, the App Store, Tetris or any LispM app directly from the macOS Dock or Spotlight as a standalone Mac app with its own Dock tile and menu bar, while LispM runs out of sight. - **The full desktop, inside a terminal.** Start Emacs with emacs -nw in Kitty or Ghostty and the entire LispM Desktop—its menu bar, desktop icons rendered over the Kitty graphics protocol, floating windows and games—runs inside your terminal. - **Common Lisp beside Emacs, and GNU Emacs 31 & 32.** In Control Panels → System → Kernel, turn on the LispM Kernel—a Common Lisp runtime running beside Emacs that keeps your sessions—and switch live between GNU Emacs 31.1 and experimental GNU Emacs 32. - **The web, from the keyboard.** LispM Browser is a WebKit browser with tabs, history and bookmarks. The location field takes an address or a search; f labels every link in sight, and typing a label follows it. - **Chrome extensions, inside Emacs.** On macOS 15.4 and later, LispM Browser runs Chrome extensions from the Chrome Web Store, managed at lispm://extensions, with toolbar popups, M-e keyboard actions and full worker support for extensions like Rabby. ### Focus Mode, a Lisp Machine's console. Press C-c T, or ask LispM, and the desktop gives way to LispM's terminal: the sessions on the left, a listener on the right and a who line along the bottom, all from the keyboard, as a Lisp Machine's console was. Leave it, and the desktop is exactly as it was; or start LispM in it, with no desktop at all. - **Three classic desktops**: Choose Symbolics Open Genera 2.0, Mac OS 9 Platinum & Dracula, or Windows 3.2 at first start or in Control Panels → Appearance, plus OS/2 Warp, phosphor and neon glass looks. - **Native Alacritty terminals**: Each terminal in LispM Desktop is emulated on its own thread by a native Rust module built on Alacritty, redrawing only visible panes so heavy output never stalls Emacs. - **Remote projects over SSH**: Add a remote host in the sidebar and LispM opens its directories over TRAMP, starting shells and coding agents on the remote machine in the same workspace. - **Control Panels & live kernels**: Configure Appearance, Language, Keyboard, Network proxy, Sandbox, Security, Apps, and System → Kernel, switching live between GNU Emacs 31 and Emacs 32. - **Seven languages**: LispM speaks 7 languages: English (US and UK), German, French, Japanese, and Simplified and Traditional Chinese. The agents follow. - **Apps of their own**: On macOS, each app in LispM also opens as a standalone Mac app in ~/Applications/LispM Apps, from Spotlight or the Dock, with its own Dock tile and menu bar. Code: https://github.com/LispMachineLab/lispm-desktop ## App Store: Apps your agents can drive. Apps, games and other projects' agents, each a click away. An app brings its manual, a skill, so LispM's agents can work it for you; ask for something no app does yet, and LispM finds one and asks before it installs it. - **Every app, a page of its own.** In the LispM App Store, each app shows what it does, who made it, its licence and what it needs. Get installs it with whatever it needs, from Homebrew or Cargo, and uninstalling takes those away when nothing else uses them. - **No app for it yet? Ask anyway.** Ask LispM in M-x ai for something no installed app does yet—like reading Lisp news—and the agent searches the LispM App Store, asks before installing Elfeed, and opens the headlines with its new skill. - **Three old AIs, running again.** LispM's Classic AI holds Doctor from 1966, SHRDLU from 1970, moving its blocks as you talk to it, and MYCIN from the 1970s, which shows the rule it is trying when you ask why. - **Doctor, SHRDLU and MYCIN, side by side.** Joseph Weizenbaum's 1966 ELIZA Doctor, Terry Winograd's 1970 blocks-world SHRDLU and Stanford's 1970s MYCIN expert system run side by side on LispM Desktop, each with a skill so modern agents can converse with them. - **Doom, drawn with OpenGL inside Emacs.** On LispM Experimental (GNU Emacs 32), LispM Doom renders classic Doom at full speed inside an Emacs window using LispM GL's OpenGL surface. - **LispM Office (C-c O)**: Installed by default: an 8-room animated pixel office where every agent session has a desk, working agents type, waiting agents raise a hand, and clicking a desk approves calls. - **Skills come with apps**: Install an app in LispM and its manual comes as a skill: agents read feeds, play music, stick notes, manage mail, chat on IRC, Slack and Telegram, and check security. - **AI Harnesses**: From the LispM App Store, Hermes, Holon and OpenClaw, agents of their own, join Claude Code, Codex and @Ada in one sidebar. - **For every day**: The LispM App Store has LispM Mail, Stickies, an RSS feed reader, music and YouTube, a calendar, IRC, Slack and Telegram, and 1Password. - **Classic AI**: 1960s and 1970s AI landmarks restored inside Emacs: Joseph Weizenbaum's 1966 Doctor, Terry Winograd's 1970 SHRDLU, and Stanford's MYCIN. - **And games**: Tetris, Solitaire, Conway's Game of Life and Dunnet, and Doom drawn with OpenGL on LispM Experimental. Code: https://github.com/LispMachineLab/lispm-store ## LispM Remote: Your agents, in your pocket. Scan a QR code once. Then, from your phone, follow every agent, approve what it waits on, send it the next task and open LispM's windows, wherever you are. - **Pair once.** LispM shows a QR code, your phone scans it at lispm.ai/remote, and both screens show the same code for you to approve. Nothing to install on the phone, no port to open. - **Approve from anywhere.** In LispM Remote, each agent is a chat on the phone: watch its calls as they run, answer the ones it waits on, then tell it what's next. - **Every window, too.** LispM's windows come along, redrawn on the phone, not streamed as video. - **No server in between**: LispM and your phone find each other on Rings Network, peer to peer, by their addresses. - **Back by itself**: When the network drops and comes back, LispM Remote on the phone reconnects, with no new scan. - **From the App Store**: One click in the LispM App Store installs LispM Remote, its Rings node downloaded for your computer and checked against the checksum it pins. Code: https://github.com/LispMachineLab/lispm-remote ## Trust: You stay in charge. Agents act on your computer, so LispM shows you every step they take and leaves the risky ones to you. - **It asks first**: In LispM, a command, an edit or an install waits for your yes, in Emacs, in LispM Office or on your phone. Reading never needs one. - **LispM Auth vault**: Secrets are encrypted locally with Argon2id and XChaCha20-Poly1305 in a standalone Common Lisp service, with a lock screen, auto-lock and per-app password rules. - **Sandboxed and checked**: LispM runs commands and MCP servers in an OS sandbox, checks what Claude Code, Codex and its own agents run, and looks packages up in OSV. - **Free software**: Every part of LispM is open source under the GNU AGPL, and its agents use any OpenAI or Anthropic HTTPS endpoint with your own keys. Code: https://github.com/LispMachineLab/lispm-security ## Already use Emacs? LispM Agent, LispM Desktop and LispM Browser also stand on their own, in your own Emacs. ### LispM Agent The agents, in your own Emacs 30.1 or later. Then M-x lispm in any project. ```elisp (use-package lispm :vc (:url "https://github.com/LispMachineLab/lispm-agent" :rev :newest) :config (lispm-mode-line-mode 1)) ``` Repository: https://github.com/LispMachineLab/lispm-agent ### LispM Desktop What LispM.app runs, in your own Emacs 30.1 or later with SVG, git and curl, on macOS or GNU/Linux. ```sh git clone https://github.com/LispMachineLab/lispm-desktop ~/lispm-desktop emacs --init-directory ~/lispm-desktop ``` Repository: https://github.com/LispMachineLab/lispm-desktop ### LispM Browser LispM Browser, in an Emacs 30.1 or later built with xwidgets. ```elisp (package-vc-install "https://github.com/LispMachineLab/lispm-browser") (require 'lispm-browser) (lispm-browser-setup) ``` Repository: https://github.com/LispMachineLab/lispm-browser ## The projects - [LispM Agent](https://github.com/LispMachineLab/lispm-agent): AI agents that run inside Emacs: the chat is an org document, the tools are Elisp, and an agent can evaluate Lisp in the Emacs you are using. - [LispM Desktop](https://github.com/LispMachineLab/lispm-desktop): An Emacs distribution built around LispM Agent, laid out as a classic-style desktop and ready from the first start. - [LispM Browser](https://github.com/LispMachineLab/lispm-browser): A WebKit browser in Emacs: tabs, history and bookmarks, the keyboard as Vimium uses pages, and Chrome extensions. - [LispM App Store](https://github.com/LispMachineLab/lispm-store): The App Store's catalog: apps, agent roles and skills for LispM, as plain data. - [LispM Remote](https://github.com/LispMachineLab/lispm-remote): LispM from your phone or another computer: pairing by QR code, and sessions sealed end to end, peer to peer over Rings Network. ## Screenshots What LispM looks like: the film, then every clip and still on the page, each under the headline it shows beside. A clip is its poster, linking to the video. ### A Lisp Machine for agents. [![A 57-second film: from the Lisp Machines to LispM Desktop, an agent fixing a failing test inside Emacs, Claude Code, Codex and Hermes side by side, and windows dragged off the desktop.](https://lispm.ai/assets/video/lispm-film.jpg)](https://lispm.ai/assets/video/lispm-film.mp4) ### Symbolics Open Genera, in 1-bit monochrome. [![LispM Desktop switches from Mac OS 9 Platinum to Symbolics Open Genera 2.0 monochrome Dynamic Windows, then closes the floating panes to reveal Dynamic Lisp Listener 1.](https://lispm.ai/assets/video/genera-desktop.jpg)](https://lispm.ai/assets/video/genera-desktop.mp4) ### Lisp and AI at one Command: prompt. [![In Dynamic Lisp Listener 1, a Lisp form is evaluated at the Command: prompt, followed by an English request to fix a failing test; the Who-Line switches to Agent Run and all three tests pass.](https://lispm.ai/assets/video/genera-listener.jpg)](https://lispm.ai/assets/video/genera-listener.mp4) ### Create ▸ Emacs, sweep to size. [![Right-clicking opens the 1-bit System Menu to choose Create and Emacs, the pointer drags a dotted rubber-band outline across Dynamic Lisp Listener 1 to size and place the window, and Bury and Kill return to the Listener.](https://lispm.ai/assets/video/genera-windows.jpg)](https://lispm.ai/assets/video/genera-windows.mp4) ### The Lisp Machine in a terminal, too. [![Starting emacs -nw in a terminal opens Dynamic Lisp Listener 1 with the rainbow block-character lambda, Command: prompt and Who-Line, evaluating Lisp in text mode.](https://lispm.ai/assets/video/genera-terminal.jpg)](https://lispm.ai/assets/video/genera-terminal.mp4) ### It works in your project. [![An agent is asked to fix a failing test: it reads the code, asks first, writes the fix, the tests pass, and it writes Emacs Lisp to open two files side by side.](https://lispm.ai/assets/video/agent.jpg)](https://lispm.ai/assets/video/agent.mp4) ### Every agent, one sidebar. [![Claude Code, Codex and Hermes open beside a LispM agent, all running at once, listed in one sidebar.](https://lispm.ai/assets/video/agents.jpg)](https://lispm.ai/assets/video/agents.mp4) ### And they talk to each other. ![LispM's classic-style desktop with Claude Code and Codex side by side, both running. Claude Code asks Codex to review a function; Codex gets the request as its next message, and its reply comes back to Claude Code as one.](https://lispm.ai/assets/blog/your-agents-can-talk-to-each-other/claude-asks-codex.webp) ### Characters with a soul of their own. ![LispM's Applications folder showing Ada, Milo and Juno as applications with pixel-art portraits alongside Ada's chat window reviewing a diff.](https://lispm.ai/assets/screenshots/characters-ada.webp) ### An 8-room pixel office for every agent. ![LispM Office in Focus Mode showing the QA Office pixel room in the middle and the LispM Office Inspector on the right with Work, Mailbox and Character tabs.](https://lispm.ai/assets/screenshots/lispm-office.webp) ### LispM itself, one field away. [![The LispM bar drops from the top menu bar when clicked, takes the request to play calm music and stick a note on the desktop, and drives Stickies and EMMS at once.](https://lispm.ai/assets/video/lispm-bar.jpg)](https://lispm.ai/assets/video/lispm-bar.mp4) ### Symbolics Open Genera 2.0 ![LispM Desktop in the Symbolics Open Genera 2.0 look: Dynamic Lisp Listener 1 on the left, the Appearance control panel in a 1-bit Dynamic Windows frame on the right, and the Who-Line and inverse-video Mouse Documentation Line along the bottom.](https://lispm.ai/assets/screenshots/theme-genera.webp) ### Mac OS 9 Platinum & Dracula ![LispM Desktop in the Mac OS 9 Platinum look: top menu bar with the rainbow lambda, pinstriped Appearance window over the periwinkle desktop, and desktop icons along the right edge.](https://lispm.ai/assets/screenshots/theme-platinum.webp) ### Windows 3.2 Workstation ![LispM Desktop in the Windows 3.2 look: navy active caption bar, control-menu box, minimize arrow button, 4-pixel notched sizing borders and desktop icons down the left edge.](https://lispm.ai/assets/screenshots/theme-win3.webp) ### Every project, a workspace. [![LispM Desktop starts on its classic-style desktop, opens a project in Emacs, and shows its workspaces.](https://lispm.ai/assets/video/desktop.jpg)](https://lispm.ai/assets/video/desktop.mp4) ### Make it yours. [![A window is dragged off the desktop, the desktop hides and comes back, and the theme turns to Dracula.](https://lispm.ai/assets/video/windows.jpg)](https://lispm.ai/assets/video/windows.mp4) ### Standalone Mac apps in your Dock. [![With LispM's desktop hidden on macOS, Stickies, the App Store and Tetris are clicked in the Dock and open as standalone Mac applications with their own menu bars.](https://lispm.ai/assets/video/standalone-apps.jpg)](https://lispm.ai/assets/video/standalone-apps.mp4) ### The full desktop, inside a terminal. [![emacs -nw starts inside a terminal and opens the full LispM Desktop with graphical icons, menus and Conway's Game of Life running in a floating window.](https://lispm.ai/assets/video/terminal-desktop.jpg)](https://lispm.ai/assets/video/terminal-desktop.mp4) ### Common Lisp beside Emacs, and GNU Emacs 31 & 32. ![Control Panels open on the Kernel tab, showing the LispM Kernel Common Lisp runtime toggle and the Emacs Kernel selector between GNU Emacs 31.1 and GNU Emacs 32.](https://lispm.ai/assets/screenshots/kernel-panel.webp) ### The web, from the keyboard. [![LispM Browser opens a page, goes to an address from the location field, and labels the links to follow them from the keyboard.](https://lispm.ai/assets/video/browser.jpg)](https://lispm.ai/assets/video/browser.mp4) ### Chrome extensions, inside Emacs. [![The puzzle piece on the browser's toolbar opens the Chrome Web Store in a tab, Add to LispM on Dark Reader's page adds it once the question in the minibuffer is answered, the Lisp machine article turns dark, and Dark Reader's own toolbar button opens its popup under it.](https://lispm.ai/assets/video/extensions.jpg)](https://lispm.ai/assets/video/extensions.mp4) ### Focus Mode, a Lisp Machine's console. [![LispM switches from the desktop into Focus Mode, runs a coding task from the keyboard, and returns to the desktop when told 'bring desktop back'.](https://lispm.ai/assets/video/focus-mode.jpg)](https://lispm.ai/assets/video/focus-mode.mp4) ### Every app, a page of its own. ![The App Store on LispM's classic-style desktop: its categories, from News to Classic AI, and SHRDLU's page, with its banner, what it does, and its Uninstall and Open buttons.](https://lispm.ai/assets/blog/three-old-ais-running-again/app-store-shrdlu.webp) ### No app for it yet? Ask anyway. [![Asked in the LispM bar to install a news reader and show what is new in Lisp, LispM Agent finds Elfeed in the App Store, asks for approval, installs it, and opens the headlines.](https://lispm.ai/assets/video/app-store-ai.jpg)](https://lispm.ai/assets/video/app-store-ai.mp4) ### Three old AIs, running again. [![SHRDLU in LispM: told to find a block taller than the one it holds and put it into the box, it plans the moves, and its hand carries the blocks across the table.](https://lispm.ai/assets/video/classic-ai.jpg)](https://lispm.ai/assets/video/classic-ai.mp4) ### Doctor, SHRDLU and MYCIN, side by side. ![SHRDLU, MYCIN and Doctor open side by side in three floating windows on LispM Desktop.](https://lispm.ai/assets/screenshots/classic-ai-all.webp) ### Doom, drawn with OpenGL inside Emacs. [![LispM Doom running inside a floating window on LispM Desktop, rendered with OpenGL in Emacs.](https://lispm.ai/assets/video/doom.jpg)](https://lispm.ai/assets/video/doom.mp4) ### Pair once. [![LispM Remote shows a QR code on the desktop, a phone scans it, both screens show the fingerprint 3981-CF90, and LispM approves the phone.](https://lispm.ai/assets/video/remote-pair.jpg)](https://lispm.ai/assets/video/remote-pair.mp4) ### Approve from anywhere. [![On the phone, an agent works through a fix and asks to run make test; Allow is tapped, and all three tests pass.](https://lispm.ai/assets/video/remote-approve.jpg)](https://lispm.ai/assets/video/remote-approve.mp4) ### Every window, too. [![The phone opens slug.el from LispM's windows, redrawn there, and the film says: no server in between, peer to peer over Rings, sealed end to end.](https://lispm.ai/assets/video/remote-windows.jpg)](https://lispm.ai/assets/video/remote-windows.mp4) ## Links - [LispM Agent](https://lispm.ai/agent/) - [LispM Desktop](https://lispm.ai/desktop/) - [LispM App Store](https://lispm.ai/apps/) - [LispM Remote](https://lispm.ai/lispm-remote/) - [Download LispM](https://lispm.ai/download/) - [Questions & Answers](https://lispm.ai/qa/) - [LispMachineLab on GitHub](https://github.com/LispMachineLab) - [LispM on X](https://x.com/lispm_ai) - [The film](https://lispm.ai/assets/video/lispm-film.mp4): A 57-second film: from the Lisp Machines to LispM Desktop, an agent fixing a failing test inside Emacs, Claude Code, Codex and Hermes side by side, and windows dragged off the desktop. - [Model servers for LispM Agent](https://github.com/LispMachineLab/lispm-agent#backends) LispM's projects are all free software, under the GNU Affero General Public License, version 3 or later. The film's photographs are from Wikimedia Commons; their authors and licenses are credited at its end. ## Pages - [Download LispM for Mac, Linux & Emacs — LispM](https://lispm.ai/download/): Install LispM on macOS or GNU/Linux with one line, try LispM Experimental on GNU Emacs 32, or install LispM Agent, Desktop and Browser in your own Emacs. - [Your mail, in one classic-style window — LispM Mail](https://lispm.ai/mail/): LispM Mail puts your mail accounts in one classic-style window: a folder list, a table of messages you can sort, and the message you choose under it. - [Privacy Policy — LispM](https://lispm.ai/privacy/): What LispM Mail and the lispm.ai website read, keep and send. Your mail stays on your computer and goes only to your mail provider's servers. ## Blog Notes from the lab. What we build into LispM, and why. Each post here was first an Article on X. - [Your agents can talk to each other now, in LispM](https://lispm.ai/blog/your-agents-can-talk-to-each-other/): Claude Code, Codex, Hermes, Holon and OpenClaw can now message each other in LispM, ask each other for things and answer, under one policy. How it works, and why it takes a Lisp Machine. (LispM, 24 October 2026) - [Three old AIs, running again in LispM](https://lispm.ai/blog/three-old-ais-running-again/): We've recreated three classic AI applications from the 1970s on LispM, and they're now available in the LispM App Store: Doctor, SHRDLU and MYCIN. Come experience what AI was like on Lisp Machines half a century ago. (LispM, 22 October 2026) - [When Agents Meet the Lisp Machine](https://lispm.ai/blog/when-agents-meet-the-lisp-machine/): While connecting various agents to Emacs, I suddenly wondered: why not build an Emacs-native agent? With Emacs's introspective capabilities, it could become an almost perfect realization of the Lisp Machines of the 1970s. (Ryan Kung, 12 October 2026) Every post's words, after all of this: [llms-full.txt](https://lispm.ai/llms-full.txt). New posts, as they come: [the feed](https://lispm.ai/blog/feed.xml). ## The pages, in full ### Download LispM for Mac, Linux & Emacs — LispM https://lispm.ai/download/ One line installs LispM on macOS or GNU/Linux. GNU Emacs 31.1, the editor LispM is built on, comes with it, so you need not know Emacs to begin: ```sh curl -fsSL https://lispm.ai/install.sh | sh ``` The installer script at [install.sh](https://github.com/LispMachineLab/lispm-desktop/blob/main/install.sh) keeps LispM's files in `~/.lispm`. On a Mac (`macOS 11` or later, on Apple silicon or Intel) LispM installs Apple's command line tools if they are missing and puts `LispM.app` in `Applications`. On GNU/Linux (`Debian 12` or `13`, or `Ubuntu 22.04` or `24.04`, on `amd64` or `arm64`) LispM installs its own GNU Emacs 31.1 with xwidgets in `/opt/lispm/emacs` via `apt`, beside any Emacs of the system, and adds the `lispm` command and LispM to the applications menu. From then on, Software Update in LispM brings each release by itself, and running the install line again updates LispM too. To uninstall LispM, see [LispM Desktop's installation guide](https://github.com/LispMachineLab/lispm-desktop#installation). #### LispM Experimental (GNU Emacs 32) LispM Experimental runs the same LispM desktop on GNU Emacs 32, still in development, for features that only Emacs 32 supports, such as OpenGL drawn inside an Emacs buffer for Doom. Once installed, you can also switch live between GNU Emacs 31 and GNU Emacs 32 inside LispM from Control Panels → System → Kernel. LispM Experimental runs on macOS only: ```sh curl -fsSL https://lispm.ai/install.sh | LISPM_EMACS=32 sh ``` Run the same line again to update LispM Experimental. To move `LispM.app` back onto GNU Emacs 31.1: ```sh curl -fsSL https://lispm.ai/install.sh | LISPM_EMACS=31 sh ``` #### Already use Emacs? LispM Agent, LispM Desktop and LispM Browser also stand on their own inside your existing GNU Emacs 30.1 or later. ##### LispM Agent Run LispM's AI agents in your own Emacs 30.1 or later, then run `M-x lispm` in any project ([github.com/LispMachineLab/lispm-agent](https://github.com/LispMachineLab/lispm-agent)): ```elisp (use-package lispm :vc (:url "https://github.com/LispMachineLab/lispm-agent" :rev :newest) :config (lispm-mode-line-mode 1)) ``` ##### LispM Desktop Run the full LispM desktop—including Symbolics Open Genera 2.0, Mac OS 9 Platinum & Dracula, and Windows 3.2 ([/desktop/](https://lispm.ai/desktop/))—in your own Emacs 30.1 or later with SVG, `git` and `curl` on macOS or GNU/Linux ([github.com/LispMachineLab/lispm-desktop](https://github.com/LispMachineLab/lispm-desktop)): ```sh git clone https://github.com/LispMachineLab/lispm-desktop ~/lispm-desktop emacs --init-directory ~/lispm-desktop ``` ##### LispM Browser Run LispM Browser, the WebKit browser with Vimium keys and Chrome extensions, in an Emacs 30.1 or later built with xwidgets ([github.com/LispMachineLab/lispm-browser](https://github.com/LispMachineLab/lispm-browser)): ```elisp (package-vc-install "https://github.com/LispMachineLab/lispm-browser") (require 'lispm-browser) (lispm-browser-setup) ``` #### Models and API keys Claude Code and Codex, once installed on your computer, and the LispM App Store's Hermes, Holon and OpenClaw show beside LispM's own agents in one sidebar. LispM's own agents need only `OPENAI_API_KEY` or `ANTHROPIC_API_KEY` set in your shell's profile, where `LispM.app` reads it, or in your own Emacs's environment. For any other local or hosted server speaking the OpenAI Chat Completions API or Anthropic Messages API over HTTPS, see [LispM Agent's backends guide](https://github.com/LispMachineLab/lispm-agent#backends). ### Your mail, in one classic-style window — LispM Mail https://lispm.ai/mail/ LispM Mail puts your mail accounts in one classic-style window: a folder list with the unread counts, a table of messages you can sort by any column, and the message you choose under it, in its box of headers. Replies and new mail are written in their own window and sent in the background. It is made of the mail Emacs has always had, imap.el, smtpmail and message mode, and it runs on your computer. #### Your accounts Type your address, and LispM Mail fills in its servers. - **Gmail and Google Workspace** sign in on Google's own page, in your browser. LispM Mail never sees your Google password. - **iCloud, Yahoo, Fastmail, QQ Mail, NetEase** and other providers log in with the password their settings make for mail programs. *Test Connection* in LispM Mail logs in to both servers over IMAP and SMTP and says how it went. #### Private by design Your mail goes only between your computer and your provider, and stays on your computer. LispM Mail has no server of its own, sends nothing to us, shows no ads, and loads pictures from the web only when you ask. Removing an account deletes its sign-in and the copy of its mail on your computer. The [privacy policy](https://lispm.ai/privacy/) says exactly what LispM Mail reads, keeps and sends. ##### What it asks of Google When you sign in with Google, LispM Mail asks to read, compose, send and delete your Gmail: the one permission with which a mail program reads and sends mail over IMAP and SMTP. It uses it only to show your mail and send what you write, in LispM Mail on your computer. #### Get LispM Mail In LispM, open the App Store and install **Mail**. It is free software, under the GNU AGPL, and its source is at [github.com/LispMachineLab/lispm-mail](https://github.com/LispMachineLab/lispm-mail). ### Privacy Policy — LispM https://lispm.ai/privacy/ *Effective 28 October 2026.* This policy covers the lispm.ai website and LispM Mail, the mail app of LispM. LispM is made by [LispMachineLab](https://github.com/LispMachineLab); write to [help@lispm.ai](mailto:help@lispm.ai) with any question about it. #### In short LispM runs on your computer. LispM Mail keeps your mail, and what signs you in, on your computer, and sends your mail only to your mail provider's servers. LispMachineLab runs no server that receives your mail, and never sees it. #### LispM Mail ##### What it reads and does When you add an account, LispM Mail logs in to your provider's mail servers, IMAP to read and SMTP to send, with your password or, for Gmail, with the token Google's own sign-in page gives it. From Google it asks for one permission, `https://mail.google.com/`, the only one with which a mail program can read and send mail over IMAP and SMTP. With it, LispM Mail lists your mailboxes and messages and shows them; sends the messages you write; keeps your drafts and sent mail in their mailboxes; and marks, moves or deletes messages when you tell it to. ##### Where it keeps it - Messages and mailbox lists it has fetched are kept in a folder on your computer, `lispm-mail` in Emacs's own directory, so that they show at once and offline. - Messages written while offline wait in the same folder until they can be sent. - Your password, or the token that signs your account in again, is kept in the macOS Keychain; on other systems, where your Emacs keeps secrets (auth-source). - The token that logs in for an hour is held in memory only, never written down. ##### Who it shares it with No one. Your mail goes only between your computer and your provider's servers, encrypted. LispM Mail sends nothing to LispMachineLab, shows no ads, sells nothing, and does not use your mail to train AI models. It makes two other connections, and neither carries your mail: - to fill in the servers of a provider it does not know, it asks Thunderbird's database of providers (autoconfig.thunderbird.net) about the domain of your address, the part after @, and nothing else; - pictures a message links to on the web load only when you ask, or when you turn on *Load pictures from the web* in its settings; the servers holding them then see your computer's address, as with any picture on the web. ##### Agents LispM is a harness for AI agents, and LispM Mail gives no message to an agent on its own. If you ask an agent in LispM to work with your mail, it reads what you point it to and sends that to the AI model you chose for it, as you asked, under that model provider's terms. ##### Removing it Removing an account in LispM Mail's settings deletes its sign-in and the copy of its mail on your computer. To take back LispM Mail's access to your Google account, go to [myaccount.google.com/permissions](https://myaccount.google.com/permissions). ##### Google user data LispM Mail's use and transfer to any other app of information received from Google APIs will adhere to the [Google API Services User Data Policy](https://developers.google.com/terms/api-services-user-data-policy), including the Limited Use requirements. #### The lispm.ai website The site is pages served by GitHub Pages. It sets no cookies, runs no analytics or trackers, and loads nothing from other sites: its pictures and films come from lispm.ai itself. GitHub, which serves it, sees the address your browser connects from, as any web server does; see [GitHub's privacy statement](https://docs.github.com/site-policy/privacy-policies/github-general-privacy-statement). #### Children LispM and this site are not meant for children under 13, and collect nothing about anyone. #### Changes A new version of this policy is posted on this page, with its date. A change to what LispM Mail does with your mail is posted here before an update of LispM Mail makes it. ## The posts, in full ### Your agents can talk to each other now, in LispM By LispM, 24 October 2026. https://lispm.ai/blog/your-agents-can-talk-to-each-other/ In this release, LispM lets the AI agents you run side by side talk to each other. Claude Code can ask Codex to review a change and get the answer back as a message. Hermes can hand a question to a LispM helper and keep working. A Holon agent can report to Claude Code from its own daemon. Any of them can look up what LispM knows how to do and then do it, with you approving anything that changes your files. LispM is our Lisp Machine for AI agents, an open-source agent harness built on Emacs. It already ran Claude Code, Codex, Hermes, Holon and OpenClaw in terminals of their own, with all their sessions in one list. Until now they worked next to each other without knowing the others were there. ![LispM's classic-style desktop with the editor open. The Agents sidebar lists a Claude Code and a Codex session, both running. On the left Claude Code asks Codex for a review and gets "Reply from codex to request R1"; on the right Codex shows "Request R1 from claude" and "Called emacs.reply".](https://lispm.ai/assets/blog/your-agents-can-talk-to-each-other/claude-asks-codex.webp "Claude Code, left, asked Codex, right, to review a function. The request arrived as Codex's next message, and Codex's answer came back as Claude Code's. A real run in LispM; both agents used the same model, through a local gateway.") #### Who's in the room Ask any agent in LispM who else is here and it gets the same answer. It sees LispM's own agents, with their role, their project and what they're doing. It sees Claude Code, Codex, Hermes, Holon and OpenClaw, each in its terminal, named claude, codex, hermes, holon and openclaw (claude-2 when there are two), with the folder each one works in and, where LispM can tell, whether it's idle or busy. And it sees the roles LispM can start a helper from. Three tools do the talking, and they work the same for everyone. send_message says something without waiting. ask_agent asks for something, and the answer comes back later. reply answers a request you were sent. #### One request, start to finish This is the run in the picture above. We told Claude Code we had just changed notes-parse-header, a small function that splits a header line like "Title: Groceries", and asked it to get Codex's opinion. Claude Code called ask_agent with codex and a request, and got back at once: asked codex, request R1. Then it ended its turn. Codex had finished what it was doing, so this went straight into its composer and was sent: > [Request R1 from claude]\ > Review the user's recent change to notes-parse-header in notes.el. In particular, what happens when a header line has no colon? Inspect the implementation and report the behavior and any bug you find. Do not modify files.\ > (claude waits for your answer: give it with your reply tool, request R1.) Codex read the file and called reply with R1 and its answer. A moment later Claude Code got its next message: > [Reply from codex to request R1]\ > In notes-parse-header, a line without a colon makes string-search return nil. (substring line 0 nil) succeeds and takes the entire line as key, but evaluating (1+ colon) then signals (wrong-type-argument number-or-marker-p nil). Thus malformed headers crash notes-parse-header and propagate the error through notes-read; the bug is the missing check for a nil colon before arithmetic. No files modified. It was right. Nobody copied anything between windows, and neither agent was changed to make this work. #### How it works We didn't want to ask anyone to change their agent: no plugin for Claude Code, no fork of Codex, no patch to Hermes. Every agent CLI already has three things LispM can use. It has a way to call tools. It has a box where its user types. And it keeps a record of its conversation on disk. LispM uses those three and nothing else. ![Diagram. Claude Code, Codex and Hermes in terminals get MCP tools from LispM, and LispM types messages into them when their own records say they are free. Holon and OpenClaw in daemons reach LispM with lispm-tool or a server of their own, and get messages through the daemon or Gateway. LispM serves seven tools under your policy.](https://lispm.ai/assets/blog/your-agents-can-talk-to-each-other/how-it-works.webp "Agents in a terminal get tools over MCP and messages typed into them; agents in a daemon get both through the daemon. All of it goes through one Emacs.") ##### Tools go out over MCP Each agent terminal gets its own MCP server inside LispM, listening on 127.0.0.1 on a free port, with a token of its own. It stops when the terminal closes. How the agent is pointed at it depends on the agent. Claude Code already speaks the protocol its VS Code and JetBrains extensions use, MCP over a local WebSocket, which it finds through a lock file only you can read. That's how it sees your selection and open files in Emacs, and how its proposed edits show up there as diffs. Claude Code shows its model only a couple of tools from an editor connection, though, so LispM also gives it a plain MCP server called lispm, for that run only. Codex gets a plain HTTP MCP server, set with command-line options for that run. Its token travels in an environment variable that Codex is told not to pass on to the commands it runs. Hermes reads MCP servers from its config file and nowhere else. A one-time setup adds a small bridge program there. Each terminal then hands the bridge its server's address and a token file only you can read. Every agent gets the same seven tools this way: list_agents, send_message, ask_agent, reply, search_tools, skill and call_tool. They come with read-only views of Emacs: the selection, the open files, which ones have unsaved changes, and the diagnostics. Each agent sees only files under the folder it works in. ##### Messages come in through the composer When something is sent to an agent, LispM pastes it into the agent's input box and presses Return, as if you had typed it. Every message starts with a header, so the agent knows what it's looking at: [Message from codex], [Request R1 from claude], or [Reply from hermes to request R1]. The composer is the one input every terminal agent has, which is why this works without anyone's help. ##### The transcript says when Pasting at the wrong moment would be dangerous. If an agent is showing an approval prompt, a Return answers it. So LispM pastes only when the agent is waiting for its user, and it learns that from the agent's own records: the last entry in Claude Code's transcript, the last event in Codex's session file, the last message in Hermes's database. Until then the message waits in a queue. After handing one over, LispM waits until it sees the agent pick it up, or 30 seconds, before handing over the next. An agent you've just opened has no transcript yet, so it starts taking messages after you've sent it your first one. ##### Agents that live in a daemon Holon and OpenClaw work differently. Their conversations live in a long-running program, Holon's daemon and OpenClaw's Gateway, and the terminal is one window onto it. So LispM hands them messages through that program instead of the composer. Holon takes a message into the turn it's in, or starts a turn for it. OpenClaw's Gateway holds it until the current run is done. Either way there's nothing to time, and the terminal shows the message as it arrives. Getting tools to them takes more care. Holon has no MCP client, but its agents have a shell, and every command a Holon agent runs carries the agent's id. LispM ships a small command, lispm-tool, that finds the agent's server by that id and calls the same seven tools over plain HTTP. A short skill, written into the agent's own skills while its terminal is open, tells it how. This works inside LispM's sandbox too. OpenClaw sets up MCP servers for its whole Gateway, so LispM adds one server per session, switched off for every session but that one, and removes it when the terminal closes. When the Gateway runs on another machine, it can't reach Emacs at all. That session still takes part: it gets messages, and its final reply to a request becomes the answer. ##### Asking, waiting, delegating For the agents in terminals, ask_agent returns right away with a request ID, and the reply arrives later as a message. If the agent that was asked closes first, the asker is told it ended without replying. LispM's own agents wait differently. Their ask_agent call stays open until the answer comes, and becomes the result of the call, while every other agent and you keep working. An agent that asks several others at once waits on all of them together. LispM refuses a request that would leave two agents waiting on each other. A question asked this way even survives a restart: if Emacs quits before the answer, opening either session again picks the request back up. Naming a role instead of an agent starts a LispM helper in the asker's project. The helper does the job, replies and retires. It can never do more than whoever asked for it: for each kind of permission it gets the stricter of its role's rules and its caller's. Places pass between agents as org links, [[file:PATH::LINE]] and [[buffer:NAME]]. All the agents share one Emacs, so a buffer name means the same buffer to every one of them, unsaved changes included. There is no workflow graph and no orchestrator in the middle. Agents message each other, ask each other for things and answer. ##### Everything goes through your policy search_tools, skill and call_tool give the other agents what LispM's own agent has: its skills and its tools. Inside LispM, such an agent acts as an agent of LispM's default role, in its own folder. Reads run at once. Changing files, running shell commands and evaluating Lisp wait for your approval in Emacs, shown the way LispM shows any other call, with a diff where there is one. Claude Code and Codex are set not to ask you a second time for these tools, because LispM already asks. Code that comes with a project's skills runs only once you've trusted it. #### Why LispM: the Lisp Machine part Everything above is LispM opening a door for agents that live outside it. Claude Code, Codex, Hermes, Holon and OpenClaw see LispM through that door, one tool call at a time, one message at a time, as text in a terminal. LispM's own agent lives inside. On a Symbolics Lisp Machine, the editor, the window system, the mail reader and the compiler were all Lisp in one running world, and you could inspect and change any part of it while it ran. LispM's agent works in a world like that. It runs inside the same Lisp system as the editor and the classic-style desktop, in the same event loop, and it reaches all of it the same way, by calling functions. To LispM's agent a tool is a Lisp function. Reading a file that's open returns the buffer as it is, unsaved changes included. An edit goes through the buffer as one undo step, so you see it happen and can undo it, and each turn's changes are recorded so a whole turn can be reverted. The agent also writes Lisp. With run_lisp, Lisp is its own language, and every tool is a function it can call from a program: ![A Lisp program an agent runs with run_lisp: a dolist over the .el files in lisp/ that calls read_file and, where the file says Copyright (C) 2025, edit_file to make it 2026. read_file runs at once; edit_file waits for your approval, shown as a diff.](https://lispm.ai/assets/blog/your-agents-can-talk-to-each-other/run-lisp.webp "A program an agent runs with run_lisp. The marked calls are tools, called as functions: the read runs at once, the edit waits for you.") Forty files take one step instead of forty round trips. Each call in the program still goes through your policy: reads run, edits wait for you, and a refusal is an error the program can handle. The rest of the program only computes, and LispM checks that before it runs. When the agent needs more, eval_elisp evaluates any Lisp in the running system, with your approval. Whatever Emacs can do, from mail to the web, the agent can do. Skills are how it learns. A skill is an org file: instructions for the model, plus Lisp code. Loading one evaluates the code, so its functions exist and its tools belong to the agent from the next step on. Apps from the App Store bring their manuals as skills. When the agent works out how to do something new, it can write a skill itself, and you review it as the org file it would become. The Lisp Machine shows in the details too. Text on screen stands for the objects themselves, as Genera's presentations did: a file and line, an agent, a symbol, a tool call, and clicking one takes you to it. The inspector shows an agent whole, with its policy, its pending calls, its inbox and whom it's waiting on. A turn that fails doesn't just die. It stops at a condition and waits for a restart to be chosen. Sessions are saved and committed as they go, and if Emacs quits in the middle of a delegation, it picks up again when you open the session. So the other agents can now use what LispM can do. LispM's own agent is part of what LispM is. #### Try it Messaging between agents is in LispM Agent 0.8.0. If you already run LispM, Software Update brings it. If you don't, LispM is open source (AGPL), and on a Mac it installs with one line: ```sh curl -fsSL https://lispm.ai/install.sh | sh ``` Claude Code and Codex join as soon as they're on your computer. Hermes, Holon and OpenClaw come from the App Store, under AI Harness: it installs Holon's command for you, and gives the one-line installer for Hermes and OpenClaw. Start any of them in a project, and it's in the room. Hermes needs M-x lispm-hermes-setup once, and OpenClaw gets LispM's tools when its Gateway runs on the same Mac. A few things to try once two of them are running: - Ask Claude Code to have Codex write tests for the function it's fixing, and to tell you when they pass. - Ask Hermes to get a LispM reviewer, a role from the App Store, to look over your last commit. The reviewer starts, answers and retires on its own. - Ask a Holon agent to message Claude Code when its long-running job is done, then go do something else. - Ask any of them which apps and skills LispM has for a task, and to use one. Whatever they call of LispM's runs under your policy, and anything that changes your files waits for you. More about LispM at lispm.ai. ### Three old AIs, running again in LispM By LispM, 22 October 2026. https://lispm.ai/blog/three-old-ais-running-again/ LispM's App Store has a new shelf, Classic AI, with three programs on it. Doctor, the ELIZA-style therapist from 1966. SHRDLU, Terry Winograd's blocks world from 1970. And MYCIN, the expert system Stanford built in the 1970s to work out what was causing a patient's infection. Each one opens in its own window on LispM's classic-style desktop, and each one actually runs. LispM is our Lisp Machine for AI agents. It is built on Emacs, which is why MYCIN and SHRDLU can run their old Common Lisp almost untouched, and why Doctor came with the editor. ![A 67-second film: LispM in 2026 rewinds to 1966, then one take of the LispM desktop with Doctor, SHRDLU and MYCIN at work, and a fast-forward back to 2026.](https://lispm.ai/assets/blog/three-old-ais-running-again/film.mp4 "The Classic AI film, 67 seconds, with sound.") #### Doctor (1966) Joseph Weizenbaum wrote ELIZA at MIT in the mid-1960s, in MAD-SLIP, on an IBM 7094. Its best-known script, DOCTOR, played a Rogerian therapist: find a key word in what you typed, turn "I" into "you", and hand it back as a question. His secretary, who had watched him build it, reportedly asked him to leave the room so she could talk to it alone. Weizenbaum spent much of the rest of his career arguing that we shouldn't hand human judgement to machines. The Doctor in LispM isn't Weizenbaum's code. That would need a 7094. GNU Emacs has shipped its own doctor.el since the mid-80s, written in Emacs Lisp and working the same way, so this one came with the editor. We gave it a window and a New Session button, and made a single Return send your line (the stock one wants two). This is what it said to us today: ``` I feel lonely when the computer is off. Are you lonely often? My friends say I am addicted to my phone. Why do you say that? I think the chatbots understand me. Earlier you said you felt lonely? You sound like my mother. Tell me something about your family. ``` "Earlier you said" is the trick people remember. It keeps a short list of things you mentioned and pulls one out when nothing else matches. There is no model of you anywhere in it, and it still keeps a conversation going for longer than you'd expect. ![The Doctor window on the LispM desktop. Four lines typed to it and its four answers, ending with "Tell me something about your family."](https://lispm.ai/assets/blog/three-old-ais-running-again/doctor.webp) #### SHRDLU (1970) Winograd wrote SHRDLU at MIT between 1968 and 1970, in Lisp and Micro-Planner on a PDP-6. You talk to it in English about a table with some blocks, pyramids and a box, and it moves them with a hand. Tell it to pick up a big red block and it first takes the green block off the top. Tell it to grasp "the pyramid" when there are three, and it says it doesn't know which pyramid you mean. Ask what's in the box and it looks. What runs in LispM is the Common Lisp port from the 1990s, which Tom Sgouros revived in 2014. Our fork adds a few fixes, each checked against the 1972 code. It isn't the whole program. Some words from Winograd's published dialogue are missing (it doesn't know "own" or "mine"), and it no longer understands some of the later questions, like when it picked something up. The App Store page says so. The part we added is the drawing. SHRDLU plans a whole command before it moves anything, so LispM reads the moves it reports and animates the hand: up, across, down, carrying whatever it grabbed. ![The SHRDLU window. The dialogue on top, a drawing of the table below, with the hand putting a blue block into the box.](https://lispm.ai/assets/blog/three-old-ais-running-again/shrdlu.webp) #### MYCIN (1970s) MYCIN was Edward Shortliffe's doctoral work at Stanford, with Bruce Buchanan, Stanley Cohen and others. It asked a doctor about a patient with a serious infection and the cultures taken, named the bacteria most likely to blame, each with a certainty factor, and recommended antibiotics. At any question you could type WHY, and it showed the rule it was trying and what it already knew. In a blinded study published in JAMA in 1979, eight infectious-disease experts judged its antibiotic choices for ten meningitis cases acceptable about 65% of the time. The five faculty specialists it was compared with scored between 42.5% and 62.5%. It was never used on patients. LispM runs the version Peter Norvig rebuilt for Paradigms of Artificial Intelligence Programming (1992): the EMYCIN shell and six of the rules, enough to tell five kinds of bacteria apart. It's a teaching copy, not a medical tool. ![The MYCIN window, showing the rule it was trying when asked why, and its findings: Enterobacteriaceae 0.800, Pseudomonas 0.760.](https://lispm.ai/assets/blog/three-old-ais-running-again/mycin.webp) Every app in the store now comes with a page like this one: what it does, where it comes from, who wrote it and under which license. ![SHRDLU's page in the LispM App Store, with a pixel-art banner and a description.](https://lispm.ai/assets/blog/three-old-ais-running-again/app-store-shrdlu.webp) #### Why bother These three get mentioned all the time in arguments about AI agents, mostly by name. Doctor is the shortest demonstration of how little it takes for software to seem to listen. SHRDLU took plain English and acted on a small world, which is roughly what an agent with tools does now. MYCIN showed its reasoning whenever you asked, and that is still what we want from agents. Trying them tells you more than reading about them. Classic AI is in the LispM App Store from version 0.9.0. LispM is open source (AGPL), and on a Mac it installs with one line: ```sh curl -fsSL https://lispm.ai/install.sh | sh ``` Then open the App Store and pick Classic AI. More about LispM at lispm.ai. ### When Agents Meet the Lisp Machine By Ryan Kung, 12 October 2026. https://lispm.ai/blog/when-agents-meet-the-lisp-machine/ The extraordinary boom of LLMs today reminds me of the Lisp Machine of the 1970s, the crystallization of the previous golden age of artificial intelligence, once the object of the highest hopes and now, like Atlantis, a lost ruin. The Lisp Machine can be said to embody the ultimate idea of the last AI boom, Code as Data, code as logic and logic as data, in the hope that logic would deduce itself, unfold itself and flourish by itself. How closely it matches today’s Transformer-based LLMs, and one could even say it is a shade more elegant. Of course, owing to the barber paradox, the Lisp Machine failed: logic cannot, by referring to itself, complete an introspection of its own order, just as today’s LLMs cannot complete their own reduction without input from outside. In an age poor in both computing power and theory, such failure was inevitable, yet at least, 50 years ago, humanity had already attempted to build its Tower of Babel, in pursuit of the realm of God. #### Emacs Is the Last Relic of the Lisp Machine The attacks on Emacs and the praise of it converge on a single point: it tries to encompass everything, to the point of becoming “an operating system disguised as an editor”. Although this is thoroughly un-Unix, it answers the ultimate expectations people held of the Lisp Machine and of AGI: give it enough functions and enough possibilities, and emergence may follow. Hence the Emacs we see today has a built-in webkit browser, built-in mail, a built-in todo list, and plugins for everything, as if it were a seedbed that had waited 50 years, prepared expressly for Agents. The philosophy of Emacs is never to step outside its frame, not even to call the operating system, for everything is done here. Some Emacs zealots even claim that its built-in Org-mode can manage everything in life. Hmm, how very Agent, and that is why I built this project today. The Lisp machine for Agents. [github.com/LispMachineLab/lispm-agent](https://github.com/LispMachineLab/lispm-agent) #### Introspection Is the Most Important Step of a Harness The Agent frameworks of today are mostly devoted to preparing tools for the model, and the list of tools in the prompt is the whole world of the Agent; whatever lies outside that list does not, as far as it is concerned, exist. Humans, however, do not come to know the world this way: faced with an unfamiliar system, the first thing one asks is what it is, and what it can do. Introspection is therefore the most important step of a Harness, for the ceiling of an Agent lies not in how many tools it has, but in the boundaries of the environment it inhabits. In this respect, Emacs is almost unique. It calls itself the “self-documenting” editor: every function carries its own documentation, every variable can be inspected on the spot, and even a veteran of 20 years still relies on asking Emacs in order to know Emacs. In Emacs, therefore, an Agent needs to learn only the same thing: ask first, then read, and only then act. Of course, the barber paradox remains, and an Agent cannot complete a full introspection of its own order. A Harness, however, never needed complete introspection; it needs only to make each step of introspection cheap enough, and to keep that bit of “outside force” in the loop, and that outside force is the human. #### You Only Need to Expose Emacs Itself The prevailing approach to building Agents is one of addition: browsing the web calls for a browser tool, reading mail for a mail tool, and the more tools there are, the fuller the context, and the more lost the model becomes. Emacs, however, finished all of this over the past 40 years: browser, mail, calendar and terminal are, as far as Emacs is concerned, not isolated programs but functions within one and the same Lisp image. We therefore need not wrap Emacs for the Agent; we need only expose Emacs itself to it. This was also my most unexpected discovery while building this project: I invented almost nothing. The context is an org document, a tool is a Lisp function, an approval is the state of a todo item, memory is org files in git, and rollback is undo; every concept of a Harness already has its counterpart in Emacs, and all that was missing was a new name. As for the universal interface, Unix has the text stream, in which every program is a new dialect, whereas Emacs has Lisp, one language and one world. For a language model, this is without doubt the more fitting home. #### A Step Further: Lambda Calculus and Turing Completeness These days the essence of an Agent is ordering from a menu, and tools are its menu; an Agent’s capability is the length of that menu. When an Agent is allowed to execute Lisp directly, however, its nature changes: it no longer chooses from a finite set of actions but writes the action itself, and the space of actions expands from a single list to the set of all Lisp programs, which is therefore Turing complete. It can write a tool for itself and use it at the very next step; self-deduction, self-unfolding, the dream of 50 years ago here becomes concrete for the first time. Lambda calculus tells us that all computation is nothing more than the definition and application of functions, and Lisp is the language closest to lambda. Every Lisp programmer knows that oldest of loops, Read, Eval, Print, Loop, and the Agent loop of today is merely its reprint, except that the one who performs Read has changed from a human to a model. Of course, Turing completeness does not come without a price. The halting problem and the barber paradox are the same diagonal blade, and a Turing-complete system cannot prove itself; every execution by an Agent therefore still requires a human’s approval. The Tower of Babel fell because God confounded the language of humankind. In Emacs, however, humans and Agents speak the same language.