agent-shell 0.55 and the Case for Vendor-Neutral AI Tooling

The newest release of agent-shell, version 0.55, arrives with the usual catalog of fixes, features, and contributor thank-yous you would expect from an active open-source project. But the more interesting story sits underneath the changelog. agent-shell is a native Emacs mode for talking to AI coding agents, and it is built entirely on the Agent Client Protocol (ACP). That single architectural decision, made before the current round of vendor turbulence, is what makes this release worth thinking about rather than merely cataloging.

The author, Álvaro Ramírez (xenodium), frames the release around a specific anxiety. Anthropic's SDK subscription support is changing, Google has signaled the deprecation of its Gemini CLI, and the level of ACP support in newer tools like Antigravity remains unclear. Each of these is a small tremor on its own. Taken together, they describe a market where the substrate beneath your daily workflow can shift without much warning. The argument agent-shell makes, by existing, is that the way to survive that instability is to refuse to bind yourself to any one vendor's client in the first place.

The protocol as a hedge

The technical core here is worth understanding, because it explains why a one-person project can credibly claim to support more than twenty agents. ACP is a vendor-neutral protocol that sits between an editor and an AI agent, defining how prompts, tool calls, permissions, and session state move back and forth. An agent that speaks ACP can be driven by any client that speaks ACP. agent-shell is that client; the agents are interchangeable backends.

The practical consequence is visible in the supported-agents list, which now spans Claude, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, Goose, Mistral Vibe, OpenCode, Qwen Code, and newcomers like CodeBuddy, Hermes, and Kimi Code. When a vendor changes its terms or sunsets a CLI, the user swaps the backend and keeps the interface. The muscle memory, the keybindings, the editing habits built up over months, all of it survives the transition. This is the kind of portability that proprietary, single-vendor tools structurally cannot offer, because their business depends on the client and the model being the same product.

There is a deeper pattern here that goes well beyond Emacs. Every layer of computing that matured into stability did so by standardizing the interface and letting implementations compete underneath. SQL outlived particular databases. POSIX outlived particular Unixes. HTTP outlived particular browsers and servers. The AI agent space is young enough that it has not yet decided whether it wants this kind of interface, and the commercial incentives push hard in the other direction, toward lock-in. ACP is an attempt to plant the standardization flag early, and agent-shell is one of the clearest demonstrations of what users gain when that flag holds.

What actually shipped

The release is not just philosophy. The largest internal change is a new inline markdown renderer, enabled by default, that moves away from the overlay-based approach inherited from shell-maker. This sounds like plumbing, and it is, but it unlocks user-facing capability that the old design could not support. Table content is now navigable cell by cell, with TAB and S-TAB moving between cells, because the renderer no longer treats the table as an opaque overlay. Source blocks get syntax highlighting by default and a copy button that finally works from the keyboard rather than only the mouse. Blockquotes render properly, and you can select text in a response, press r, and have that selection become a quoted blockquote in a fresh prompt. These are the kinds of refinements that only become possible once the underlying representation is right, which is a useful reminder that performance work and feature work are often the same work seen from different angles.

Session handling received serious attention. A reworked session restoration system (contributed by @nhojb) now exposes four verbosity levels through agent-shell-session-restore-verbosity, ranging from a fast title-only restore to a full replay of an entire conversation. The available level depends on whether a given agent supports session/resume or session/load, and agent-shell degrades gracefully when an agent supports neither, ultimately falling back to a new session. You can now fork a session via M-x agent-shell-fork, starting a new shell that shares history up to the branch point and then diverges, which mirrors the mental model of branching in version control and is a genuinely thoughtful affordance for exploratory work with an agent.

The viewport, which the author describes as their primary mode of interaction, continues to mature. It offers a focused single-interaction view with single-key replies: y for yes, c for continue, m for more, a for again, and numbered choices for menu selections. The addition of request queueing matters more than it first appears. Previously you could only reply to an idle agent; now pressing r against a busy agent queues the request for submission when the agent frees up. That small change removes a stall from the interaction loop, letting you keep thinking and typing while the agent works.

Infrastructure improvements round out the picture. ACP connections now work over TRAMP (contributed by @martenlienen), making it possible to drive agents on remote machines. Wayland clipboard support arrives through wl-paste, Windows clipboard image pasting works through PowerShell, and a batch of Emacs 31 rendering fixes clears up header color and visibility regressions. The contributor list for these changes is long, which is itself part of the story.

The economics underneath

The most honest thread running through the release notes is financial. The author is candid that agent-shell competes against tools backed by well-funded engineering teams while being maintained by one person who recently took a demanding day job. Time spent on the project is time away from paid work. He points, half-joking and half-pointed, at the employees of large companies who use agent-shell daily and suggests they nudge their employers to sponsor it. He notes that Anthropic offers six months of free Claude Max for open-source projects with at least 5,000 GitHub stars, and that the project is roughly a fifth of the way there.

This is the uncomfortable counter-perspective to the vendor-neutrality argument, and it deserves to be stated plainly rather than smoothed over. Vendor-neutral infrastructure is a public good, and public goods are chronically underfunded precisely because their benefits are diffuse while their costs are concentrated on whoever maintains them. The same independence that makes agent-shell valuable, its freedom from any single vendor's commercial agenda, also deprives it of any single vendor's payroll. A tool that protects you from lock-in has no lock-in of its own to monetize. The author states the consequence without melodrama: unless the work becomes sustainable, he will have to focus on something that pays the bills.

That tension is the real subject of this release. The features are good, the protocol bet looks increasingly sound, and the contributor community is clearly engaged. But the long-term viability of vendor-neutral tooling depends on whether the people who benefit from it are willing to fund it, or whether they will continue to free-ride until the maintainer burns out and the project joins the deprecated CLIs it was meant to outlast. The supported-agents list grows, the renderer gets faster, the sessions fork and restore, and all of it rests on one person's continued ability to afford to care. Readers who find the tool useful can sponsor the project or simply star the repository, and the case for doing so is not charity but self-interest in keeping an exit hatch from vendor lock-in open and maintained.