UNDO AGENT / LOCAL WORKSPACE ● SYSTEM READY
command station for AI

Give AI
access to work.

UNDO is a local agent that turns AI requests into real file operations. Read code, create structure, fix errors and manage the project through short, clear commands.

SEE HOW IT WORKS → CAPABILITIES
› FILES  ·  CONTEXT  ·  BACKUPS  ·  CHECKS
STEP 1 / 6
⊞
chat.deepseek.com
↶ Undo
14:32
🔒 chat.deepseek.com
⋮
YOU
Create a Python script that prints hello
AI
Sure — copy this block:
FILE: hello.py print("hello world")
YOU
saved: hello.py (0.1K)
syntax: OK · Python
AI
✓ I see it — hello.py created, syntax OK. Ready for the next step.
● waiting for input…
↶ Undo — Project Terminal
—
clip(1) >
>
Project
readme.txt
hello.py
EMPTY
PASTE
hello.py— □ ×
print("hello world")
18+project tools
AUTObackup before change
LIVElog for every command
LOCALagent on your machine
beyond ordinary chat

AI suggests.
UNDO executes.

Instead of “open the file and paste this code” — a command that does the work. Instead of guesses — the actual content of the project. Instead of the risk of losing changes — backups and rollback.

[ 01 ]

Full access to project operations

Create, read, search, rename, delete and precisely edit files. Folders, project tree, statistics and hashes — also through commands.

[ 02 ]

Context that never gets lost

Project description, log, tasks, notes and decisions are stored together. The CTX command assembles them for the AI.

[ 03 ]

Change management

A backup before every edit, diff against the previous version, file restore and storage configuration. Experiment and roll back.

[ 04 ]

Result validation on the spot

Syntax checks for Python, JSON, HTML and JavaScript. After EDIT you immediately see whether the check passed.

[ 05 ]

Diagnostics without switching

Search text and regular expressions, open the needed lines, inspect project state and read the log right in the working loop.

[ 06 ]

Data for the next step

Context, logs and command results are returned to the clipboard. Paste the answer into the chat — the AI continues concretely.

[ 07 ]

Ctrl+C works in any layout

Ctrl+C, Ctrl+V, Ctrl+X, Ctrl+A are handled by physical keycode, so they work in Russian, Chinese, or any other keyboard layout — no switching needed.

[ 08 ]

Undo can rewrite itself

Edit Undo’s own source with Undo. It saves a backup, checks the syntax, and restarts itself in place — the tool is its own test case.

[ 09 ]

Three languages, one click

The entire UI — menus, logs, manifest — switches between English, Russian and Chinese. Undo restarts itself and comes back in the chosen language.

not just an AI bridge

Undo is also a terminal.

Type anything that doesn’t look like an AI command — and it goes straight to cmd.exe, with the output in the same log. Switch between working with AI and working with your machine without leaving the window.

> dir
app.py 2.1K
config.json 0.4K
readme.md 0.8K
(no command marker)
TYPE ANYTHING — IT GOES TO CMD.EXE
dirlist files
cd ..change folder
echo hiecho
python -Vpython
pip listpip
powershell …powershell
clearclear log
helplist commands
↑ / ↓command history
CALC: 2**16safe calculator
shortcuts that just work

Like a real terminal — but friendlier.

↑ ↓

Command history

Arrow keys cycle through what you typed. Same as in bash — just tap up and hit Enter.

RIGHT-CLICK

Context menu everywhere

In the log: copy selection, copy the whole log, clear, show clipboard, paste to input. In the input line: cut, copy, paste, select all, clear.

CTRL

Works in any layout

Ctrl+C, Ctrl+V, Ctrl+X, Ctrl+A are handled by physical keycode. Russian, Chinese, German — same keys, same behaviour.

CMD: open

Open a file with the system app

CMD: open report.pdf — Undo calls the default handler. PDF in the viewer, .py in the editor, image in the gallery.

CMD: run

Launch any program

CMD: run calc — and the Windows calculator opens. Anything the shell can start, Undo can start.

CMD: folder

Jump to the Undo folder

CMD: folder opens the folder where Undo lives — logs, backups, shots, config. One click from the terminal.

not only commands

Everything in one click.

Undo is not just a command runner. The top menu gives you the same operations as buttons — a screenshot, the project context, the whole log, the manifest for the AI. No typing needed.

AI

📋 Copy manifest for AI

The very first item in the AI menu. Click it once — the manifest is in your clipboard, ready to paste into any chat.

TOOLS

Screenshot (window)

One click — the active window goes straight to the clipboard as an image. No command, no filename, no path.

TOOLS

Screenshot (full screen)

Same, for the whole desktop. Ctrl+V into any chat — the AI sees everything.

TOOLS

📋 Copy context (CTX)

Assemble the whole project memory — description, errors, tasks, log — and put it on the clipboard in one click.

TOOLS

📋 Copy log

The full session log, ready to paste. Useful when something went wrong and you want the AI to see it.

FILE

Open Folder · Recent

Pick a project folder or jump to one of the last twenty. Undo remembers where you worked.

FILE

Edit Description…

Write what this project is about. It lands in .agent/desc.md and travels with the context every time.

SETTINGS

Font & Language

Three fonts — VT323, Consolas, Courier New. Three languages — EN, RU, ZH. Undo restarts itself and comes back with your choice.

FILE

Remembers everything

Window size, position, recent projects, current project, chosen font and language — all restored on next launch.

AI can see your screen

Show, don’t describe.

The SHOT command takes a screenshot and puts it straight into the clipboard — as an image, not text. Paste it into any chat and the AI sees exactly what you see. No plugins, no screen-share, no permissions.

SHOT:

> COMMAND: SHOT
capturing active window…
saved: shots/shot_20261016_234501.png
buffer < [image]
paste into any chat — the AI sees it
IMAGE GOES TO CLIPBOARD, NOT A FILE PATH
SHOT:active window
SHOT: fullwhole screen
SHOT: "Chrome"window by name
SHOT: wait=3after N seconds
SHOT: save=path.pngsave to file
[ 01 ]

Ask what’s on screen

AI writes “SHOT: full”, you press Ctrl+V into the chat. The AI sees the whole desktop — no description needed.

[ 02 ]

Debug without sharing a screen

Error in a window? Just SHOT: and paste. Works over any chat, any time, any place.

[ 03 ]

See the rendered result

Run a program, take a shot with SHOT: wait=2, paste it. The AI checks layout, colors, and errors visually.

every edit is verified

No blind edits.

After every EDIT, Undo runs a syntax check on the file. If something is broken, the response says CHECK FAILED — and the AI sees it before you do. Nothing lands on disk silently.

EDIT: app.py
<<<FIND>>>
def run():
print("hi")
<<<REPLACE>>>
def run():
print("hi"
<<<END>>>

> COMMAND: EDIT
ok: applied 1/1 | bak: app.py.bak_edit_...
CHECK FAILED: SyntaxError: '(' was never closed
CHECK RUNS AUTOMATICALLY AFTER EVERY EDIT
.pypy_compile
.jsonjson.loads
.html</html>, script balance
.jsbraces & parens
CHECK: pathmanual check anytime
transactional edits

All blocks or nothing.

An EDIT can carry multiple FIND/REPLACE blocks. Undo checks every block first. If a single one is missing, nothing is applied — the file never ends up half-edited. And edits are idempotent: applying the same block twice changes nothing the second time.

[ 01 ]

Atomic

All FIND blocks are validated before any write. One missing block → nothing changes. No partial states.

[ 02 ]

Idempotent

If a block is not found, Undo reports it and skips. It never duplicates lines — applying an EDIT twice is a no-op the second time.

[ 03 ]

Line-ending safe

CRLF vs LF is normalised on the fly. A Unix edit applies cleanly to a Windows file without touching the rest.

the tool is its own test case

Undo can rewrite itself.

Edit Undo’s own source with Undo. It saves a backup, runs the syntax check, then restarts itself in place — 800 ms later you’re looking at the new version, same window size and position.

EDIT: Undo.py
<<<FIND>>>
def _about(self):
<<<REPLACE>>>
def _about(self):
text = "Love each other."
<<<END>>>

> COMMAND: EDIT
ok: applied 1/1 | bak: Undo.py.bak_edit_...
check: python OK
self-edit — restarting...
[Undo] ready
SAME WINDOW · NEW CODE · 800 MS
1edit Undo.py
2backup & check
3restart in place
4same window size
5new code running
command interface

One line — one action.

Commands read like instructions. The first line defines the operation; the following lines contain the path, text or parameters.

FILE: src/app.pycreate / replace
EDIT: src/app.pyprecise block edit
APPEND / DELETEappend / delete
RENAME / TOUCH / MKDIRfile & folder ops
READ: src/app.py | 1-80read with lines
HEAD / TAIL: path | Nfirst / last N
STAT / COUNT / HASHsize, words, md5+sha1
FIND: path | textsearch in file
SEARCH: TODOsearch project
REGEX: path | patternregex search
LIST / TREEfolder / project tree
CHECK: src/app.pysyntax check
CALC: 2**16safe calculator
SNIPPET: python_cli18 code templates
BACKUPS / DIFFlist / compare
↑ ↓command history
right-clickcopy / paste menu
↑ ↓command history
right-clickcopy / paste menu
RESTORE: src/app.py | 1restore version
CLEANUP / BACKUP_RULEbackup retention
CTX: / NOTE: / TASK:project memory
REMIND: ctx=30context reminder
SHOT: / SHOT: fullscreenshots
CMD: run / open / foldersystem commands
LOG: Nlast N log lines
FILE: src/hello.py
print("hello")

> COMMAND: FILE
backup created
saved: src/hello.py
syntax: OK · Python
buffer < saved: src/hello.py
EXAMPLE COMMAND EXECUTION
closed loop

AI sees every result.
You set the pace.

All work passes through the clipboard. There are no hidden actions: the command and the response are shown in the Undo log.

01 / ASK

Set the task

Describe the result you want. If context is needed, request CTX first.

02 / COPY

Copy the command

The AI formats the command in a separate block. The Copy button puts it into the clipboard.

03 / EXECUTE

Undo runs it

The agent recognizes the marker, performs the action, shows the log and returns the result.

04 / RETURN

Paste the response back

Paste the result. The AI checks it and prepares the next well-grounded step.

change control

Bold edits.
Without the fear of losing a file.

Before FILE, EDIT, DELETE and RENAME, Undo saves a backup. You can view the diff, roll back to a chosen version and configure automatic cleanup of old backups.

✓src / main.pybackup saved
✓config.jsonbackup saved
✓README.mdbackup saved
↶RESTORE: file | 1undo change
backups clean themselves

No folder full of stale copies.

Every edit makes a backup. Every launch, Undo tidies up: files older than 30 days are deleted, only the 30 newest versions are kept per file, and anything younger than one hour is never touched.

Fully configurable from the same window:

> BACKUP_RULE: show
[BACKUP_RULE]
keep: 30
max_age: 30 days

> BACKUP_RULE: keep=50
backup_keep = 50

> BACKUP_RULE: run
cleanup triggered
the project remembers

Every session continues the previous one.

Inside each project Undo keeps a small .agent/ folder. It stores the idea, the errors you solved, the tasks still open, and a running log. One command — CTX: — collects everything into a single block of text for any AI chat.

.agent/ project.prj name, path, created desc.md what this is about context.json errors, solutions, notes tasks.json todo / done project.log running log > CTX: assemble everything into the clipboard context ready · paste into any chat
CTX:assemble context
NOTE: textadd a note
TASK: add textadd a task
TASK: done Nmark done
TASK: listlist tasks
REMIND: ctx=30reminder every N edits
[ 01 ]

New chat? No problem.

Open a fresh AI chat, paste CTX:, and the assistant knows your project name, its goals, the errors you already fixed, and what’s still on the list.

[ 02 ]

Come back a week later

Undo never forgets. Every session ends where the next one begins — no re-explaining, no “remind me what we were doing”.

[ 03 ]

Your own memory aid

Not sure what this folder was for? Run CTX: and read it yourself — description, tasks, notes, history, all in one place.

help about the program

What is Undo, really?

A small local agent that gives any AI assistant a working hand on your machine — through the clipboard, with full transparency and backups.

What it is

Undo is a terminal-style desktop application. You run it locally. The AI writes a command. You copy it into the clipboard. Undo reads the clipboard, executes the command on disk and writes the result back. You paste the result into the chat. That is the whole protocol.

No server. No account. No internet needed. No API keys. No telemetry. Everything happens on your machine.

Why it exists

Modern AI assistants are great at writing code and reasoning about it, but they cannot touch your file system. Cloud “tool use” requires accounts, keys, network and trust in a third party. Undo replaces all of that with the clipboard — the one channel every OS, every browser and every chat already supports.

How to use it — step by step

  1. Run Undo.py or Undo.exe.
  2. In your AI chat, ask: “Create a Python script that prints hello.”
  3. The AI answers with a block like the one shown above.
  4. Click Copy on that block.
  5. Undo executes within a second. It saves the file and puts the result into the clipboard.
  6. Paste the result into the chat.
  7. The AI confirms and continues.

What AI must always remember

  1. No direct file access — only through Undo.
  2. The user is the mediator: they copy and paste blocks.
  3. One command = one code block. Don’t mix commands.
  4. If an EDIT fails, read the file first, then send a new EDIT.
  5. Don’t invent paths — ask Undo: TREE: or LIST:.
  6. Always check the result — Undo returns it to the clipboard.
  7. For long commands Undo returns a compact summary: N lines.

Safety and privacy

  • No network access by design. Everything is local.
  • Every destructive operation creates a backup first.
  • Auto-cleanup keeps only the N most recent versions of each file.
  • The user is always the mediator. Nothing runs without a copy.
  • As with any shell tool — do not paste commands you don’t understand.

Compatible AI assistants

Anything that can show a text block with a Copy button: ChatGPT, Claude, DeepSeek, Gemini, local LLM frontends (Ollama, LM Studio, SillyTavern), even Notepad.

License

MIT. Take it, fork it, ship it, sell it — no questions asked.

questions and answers

The system stays under your control.

Does Undo run commands by itself?

Yes. When a command with a marker lands in the clipboard, Undo recognizes it automatically and shows the result in the log.

What if a command doesn’t work?

Undo returns an error message. Before the next edit the AI can request the file contents or specific lines to prepare a precise fix.

Can I see what changed?

Yes. The DIFF command shows the difference against the latest backup. RESTORE brings back a chosen version and saves the current state first.

How do I hand over project context?

Run CTX and paste the assembled context into the chat. It includes project metadata, description, notes, tasks and log.

Is my data sent anywhere?

No. Undo has no network code by design. Nothing leaves your machine.

Do I need Python installed?

Only if you run the .py source. The compiled .exe works on its own.

a note from the author

Hi. I made this.

This is the first program I’ve ever finished — and I want to say a few things while I have your attention.

Love each other.
Be patient. Respect one another. Value one another. Think about life.

There is nothing more important than that. Not success, not money, not even this program. All of it ends. Only what we give to others stays.

I built Undo so you could build something of your own — a small idea, a small step, a small kindness turned into code. If you’re reading this, you already know what to do next.

If you want to say hello, share a thought, or show me what you made — write to me. I read every message.

✉ NickBass@bk.ru

setup in one message

Send the manifest. That’s the whole setup.

Undo ships with a manifest — a single text document that tells any AI assistant how to work with the agent. Copy it, paste it into a new chat, and the AI instantly knows all the commands, the rules, and the backup policy. No training, no configuration.

1.Open Undo → AI menu
2.Click “Copy manifest for AI”
3.Paste it in any chat
4.AI is ready to work

Works with ChatGPT, Claude, DeepSeek, Gemini, local LLMs. Anything that can display a text block with a Copy button.

# UNDO — manifest for AI
## Who I am
Local agent on the user’s PC. Terminal window
(black background, green text). I take commands
via clipboard, execute them on disk, return
results to clipboard.

## Commands
FILE: path create / overwrite
EDIT: path FIND/REPLACE blocks
READ: path read with line numbers
BACKUPS / RESTORE version control
SHOT: / SHOT: full screenshots
CTX: project context

— 500+ lines, 3 languages, ready to paste —
THE MANIFEST IS BUILT INTO THE PROGRAM
download

Get Undo for Windows.

A single installer. One folder on your machine. No Python required, no account, no network.

DOWNLOAD UNDO_SETUP.EXE ↓
41 MBinstaller size
WIN 10/1164-bit Windows
v1.0current version
MITfree and open

Installs into %LOCALAPPDATA%\Undo. Creates a desktop shortcut. Includes an uninstaller.

READY WHEN YOU ARE

Your AI just received a workstation.

Explore the project. Make changes. Check the result. Return to any version — command after command.

EXPLORE COMMANDS →