The IDE that watches
your agents work.

Terminals that remember what they were doing. OpenCode one click away. Edits that arrive in the editor typed, word by word, the way the agent wrote them. CepelCode is a code editor built for the way coding CLIs actually work.

Download for Windows See it running

Free download · x64 installer · SHA-256 published with every release

CepelCode in Workspace mode: a session called blockcraft with a PowerShell terminal on the left and OpenCode running in a second terminal on the right. The title bar reports one agent running. — Workspace mode — a shell and OpenCode side by side, the app counting one agent running.

143resident analysers, no model, no key
66specialists on your CLI · 21 expert tier
50terminals restored at 563 MB, measured
0network calls except the update check

Three modes, one switch

The window is whatever the work is.

A dashboard, an editor and a wall of terminals want different layouts. CepelCode gives each its own mode and puts the switch dead centre, so nothing is ever two layouts fighting over the same pixels.

Home

Where you were, what the agents have been doing, what the sweep found, and the router — before you open a single file.

IDE mode: worldgen.js open with syntax colouring, the file tree, and a terminal panel serving the game on port 8000 — which the Ports tab has already noticed.

IDE

Files, tabs, breadcrumbs, diagnostics that arrive while you type, and one terminal under the code. The editor you already know how to use.

Workspace

Sessions down the side, terminals tiled across the whole window. For when the terminals are the work.

Built for agents

Everything an agent does, you can see.

The editor after an agent added a fall-damage method to player.js: the new lines are highlighted and a chip reads player.js +9/-0, Watching for edits.

Watch the agent type

A file an agent changes is not snapped into place. It arrives the way it would have been written — cut lines go at once, new text word by word under a moving cursor, the change highlighted when it lands. The buffer is never dirty while it types and always ends as the file on disk.

The chat dock on the right of the editor running OpenCode in its terminal view, with a composer underneath that reads Message the CLI.

OpenCode, one click

Checks for Node.js and installs it if it is missing, installs or updates OpenCode, then runs it — typed into a real terminal so every step is on screen. From the workspace rail or the chat dock. Log in, and go.

Terminals that remember

A restored terminal is a record, not a process: its name, its folder, what it last printed — and no shell until you press a key. Twenty terminals cost twenty emulators and zero PowerShells.

Talk to the CLI beside your code

The chat dock is a real PTY with a composer instead of a prompt line and a transcript instead of a scrolling buffer. It keeps its own width, and it has tabs — two agents on two jobs is the normal case.

143 resident analysers

Compiled into the Rust core. No model, no key, no network. They read one sweep of your workspace, each says one narrow thing well, and their findings land as Problems rows and squiggles — on every save.

The shell says so itself

Exit codes, the working directory and what actually ran come from the shell's own markers, not from reading the screen. Listening ports come from the kernel's table, attributed to the terminal that opened them.

Dictation, offline

One global key. Its own recogniser, compiled in — no download, no network — biased toward the identifiers in your codebase. Clear words with small pauses; it will not transcribe a conversation, and it says so rather than pretending.

A safe loop around every run

Checkpoint the workspace before an agent starts, review what it changed, undo the last run, keep agents in their own lanes with worktrees, and check the tree against architecture rules you wrote down.

The harness

66 specialists. 21 of them expert tier.

Driven over whichever coding CLI you already have. A router reads your request and decides who is needed — and its most common, most correct answer is nobody, do it inline. It does not spawn a fleet by reflex.

Facts first. An expert arrives with the tabulated evidence its contract asks for — the auth surfaces, the boundary map — before its first token.
Checks, not claims. Executable probes run against your tree and return pass, fail or not-applicable. A model saying "done" moves nothing.
Refusals that hold. A reply that breaks one of an expert's rules is rejected and re-asked, not noted.
A named artifact. A threat table, a seam plan, an auth surface — checked for shape before it is accepted.
Needs Python 3 and a coding CLI on your machine. The editor, the terminals and the resident analysers need neither.

Built to be trusted

Measured, not claimed.

Stays current

CepelCode checks for a new version at launch and every six hours, downloads it on your say-so, verifies the checksum, and installs it silently. Thirty days after a release, the old version asks you to update or quit — and lets you stop your running agents first.

Nothing phones home

The only network call the app itself makes is that update check. Analysis runs in a local Rust core. Dictation never leaves the machine. Your agents talk to whichever provider you configured in your CLI.

Agents do not work outside it

Every run carries a capability token the app minted for that session. A token copied to another machine fails even though the bytes are right. A person at the keyboard is trusted; a cron job nobody meant to point here is not.

The IDE that watchesyour agents work.