Aleph learns to undo (without a time machine)

Early versions of Aleph could already read a project, edit files and run commands. That was enough to make the agent useful. It was also enough to reveal an uncinematic truth: giving tools to a model is the easy part; getting it to use them without turning every change into an act of faith takes quite a bit more work.

Version v0.2.0-beta.9 grew out of that discomfort. Instead of adding another tool, we focused on everything around an action: what a person sees before approving it, what gets saved if something is interrupted, and how to go back when the result was not what they expected.

First, show the cards

When Aleph proposes editing or writing a file, it now shows a preview of the change. An edit displays the diff; a new write displays the content it will create. The question changed from “do you trust that the agent got this right?” to “do you approve these specific lines?”.

That sounds like a small distinction until the tool wants to replace a configuration, touch a long file, or fix three characters that look suspiciously like thirty. Seeing the change before execution lowers blood pressure and, as a side effect, reduces the amount of swearing directed at the computer.

Undo, with both feet on the ground

After an edit or write_file, the interface now offers undo. Aleph keeps a bounded snapshot of the previous state and can restore it without requiring a time machine, a Git ritual, or a precise memory of what used to be on line 147.

Undo also checks that the file still matches what Aleph wrote. If you edited it manually in the meantime, it will not overwrite your work. It reports a conflict and stops. Reverse gear is useful; reverse gear with your eyes closed is just another way to crash.

Plan means plan

Plan mode already prevented some writes, but one side door remained: bash. And bash, given enough enthusiasm, can write, delete and rearrange half a project before breakfast.

Plan now blocks both file tools and command execution. It also ignores remembered Build permissions from previous sessions. When you choose to plan, Aleph can investigate, read and propose; it cannot show up with a sledgehammer claiming it was “taking measurements”.

A clear permission does not make the agent less capable. It makes that capability happen when you decide.

Cancel has to cancel

Interrupting a command did not help much if its child process kept running in the background. The new implementation runs bash inside a process group and terminates the whole group on cancellation. It also limits how much stdout and stderr it keeps, so a chatty command cannot turn RAM into its complete memoirs.

Sessions are saved after every tool and also on cancellation or error. JSON writes are atomic: the new file is prepared first, then it replaces the old one. If something stops halfway through, the conversation should not turn into digital archaeology.

Downloads that remember where they were

A GGUF model can weigh several gigabytes. Previously, an interrupted connection could force a restart from zero. Aleph now resumes downloads with HTTP ranges, checks that the server actually honors them, and restarts safely if it decides not to.

When the download finishes, it verifies the GGUF header, expected size and, when Hugging Face publishes it, the LFS SHA-256 hash. Resuming quickly is good. Resuming garbage with admirable efficiency is less so.

More signals, less guessing

The agent view now shows the current phase, loop step, approximate context use and tokens per second when llama-server reports timing. It does not change what the model knows, but it explains what the model is doing and whether it is moving forward. In a local app, that distinction matters: five seconds of silence can mean inference, loading, or the software equivalent of staring out the window.

All of this is now wired into GitHub CI: Svelte validation, the frontend build, Rust tests, and the deterministic harness suite on both routes. Tests do not promise that a model will never improvise. They promise something more reasonable: when the agent edits, cancels, saves or downloads, the surrounding infrastructure behaves as agreed.

A less reckless beta

This release is less about doing more things and more about doing them in a way that can be inspected, stopped and reversed. Aleph is still beta. We are still finding odd edges, creative models and commands with opinions of their own. But when something drifts now, there are better brakes and a reverse gear.

Download Agent Aleph v0.2.0-beta.9 → Available for Linux as an AppImage and a .deb package from GitHub Releases.

In other words: the agent can still pick up the tools. Now it also shows you where it plans to use them and knows how to put them back in the drawer.