A terminal whose unit of work is an agent, not a tab.
A tab is one agent’s workspace: its transcript, its directory, its state. The panel lists what is being worked on. A mark on each row says how it is going, in a shape as well as a colour.
- 01tab
One agent, its transcript and its branch
- 02status
Written by the agent itself, over the terminal it already has
- 03output
A list of commands, each with everything it printed
- 04plugins
Sandboxed .wasm that must ask before it reaches anything
The agent reports its own status.
The program in the pane writes one escape sequence to its own terminal and exits. No socket, no pane id: the terminal it has is the pane. That is why it works from a hook, over ssh and inside a container, and why every other terminal drops it unread.
- Crook’s plugin makes Claude Code say all of it by itself. Settings › Agents connects it in one click, and Codex and Copilot CLI the same way: Crook types the agent’s own install commands into a tab you can watch, and says when the plugin is behind.
crook --agent-hooksprints the hooks to merge by hand. - The same plugin hands Claude Code
crook mcp: ask in the chat and it opens a tab or a split with a command, waits for it, reads what it printed and closes it. Only its own panes, and it can neither type into a pane nor answer a permission request. - With no hooks at all, Claude Code’s own title still says running and idle.
- A row waiting on you is washed amber and its mark carries a bell; a failed one carries a cross, so the status reads without the colour. The header counts them, and cmd+j goes to the next one.
- The window title carries the count, so a switcher tells three Crooks apart and says which one stopped for you. Behind another window, a pane that turns amber posts a desktop notification on Linux and from Crook.app on macOS, where the dock carries the count.

The panel as Crook renders it: one row per agent, the branch under the title, two related tabs folded into a group.
Drawn, not captured: the header chip, three rows, and the hook lines behind them.
Answer the agent from the tab you are in.
The moment Claude Code stops to ask, its row turns amber with the command on its second line, and the header says how many are waiting to be answered. One card holds the whole command, the tab and directory it runs in, and four buttons: Allow once, Deny, Go to tab, and Not now, which is the default.
- Allow, Deny and Go to tab wait for a second of stillness before a key or a press reaches them. There is no “always allow”.
- An Edit, MultiEdit or Write request is drawn as the change, in a diff’s colours.
- The command is drawn the way the shell will read it: left to right, with lookalikes, blank-looking characters and stray marks written out. A request with any text that is not ASCII is allowed only after it has been read as written, every such character spelled out as its code point.
- Claude Code’s own dialog stays up in its tab, and whichever is answered first wins. Inside tmux the card finds the Crook pane holding tmux’s client.
- With more than one waiting, the chord opens the list, oldest first. Let agents ask in Crook, on the Appearance page, turns answering off.


Output is a list of commands, not one scrolling screen.
Each command is a block holding its prompt, the line that was run and everything it printed. A failed one gets a red wash; the one still running gets the stripe.
- Hover copies exactly that command and its output. No neighbour’s text, no trailing blank rows.
- A command that failed says its exit code, and one that ran a second or more says for how long.
- Ten thousand commands survive a
clear, a resize and the emulator’s own history evicting anything. - An agent’s whole session is one open block. Past its newest 500 lines or so it is kept as rows rather than grid cells: 6.3 MiB for ten thousand rows at 200 columns, where it was 46.9.
- Blocks are what find, the palette and the markdown plugin work on.

Find searches every block at once.
Every finished command and the open one, counted in the bar. The current match is in the accent, the rest in amber. It is a search and not a filter, so the lines between the hits stay where they are.
Aatells capitals apart, and.*reads the query as a regular expression.- The filter is a block’s own: Filter output on its menu shows the command and only the lines that match.
- A pane with no blocks, an agent or an
sshsession, is searched through its whole scrollback.

> commands · @ tabs · # settings · ? keysOne box for everything that has a name.
Commands, open tabs and every settings row, each kind under its own heading when there is more than one kind of answer. A command row prints its chord, and its id once it is the chosen one; a tab row says where it is working; a settings row opens its page with the row on screen.
- A sigil narrows the list to one kind, and tab walks between them.
?answers “what is bound to what” from the same box.- A settings row chosen here lands the keyboard on it. Settings, Plugins, the Store and the Changes column are walked by keyboard too: tab through every control, enter to press, esc back out.

A plugin describes what it wants drawn. The host paints it.
A module runs in an interpreter with no filesystem, no network and no clock of its own. It names a badge, a meter, a chip, a panel; Crook draws them in the theme, so a plugin names no colour and no pixel. Anything from the machine it has to ask for, in sentences, and the card is where they are answered.
- The Store fetches one static
index.json. No account, no machine id, nothing about what you have installed. - Every artifact in the registry is built from source by CI and hashed. Previews live inside the module.
crook --dev-plugin .runs the one you are writing straight out oftarget/, and again on every build.

What the pirate draws in the header: the host’s own artwork by name, and one number it asked permission to read.
The parts a terminal has to get right anyway.
xterm-compatible: colour, bold, italic, underline, strikeout, the alternate screen, ten thousand lines of scrollback, SIGWINCH on resize.
cmd+d splits the focused pane right, cmd+shift+d down, so right then down is an agent beside two watchers and the same again is a 2×2. Every divider drags, at every depth.
OSC 0, 2 and 7: what you called it, else what the agent calls its work, else what it is running, else the directory it sits in.
No strip of system chrome. Drag its empty space to move the window; macOS keeps its traffic lights exactly where every Mac app has them. In a narrow window the tabs fold into a drawer.
A worktree opened from a tab folds the two into a group under its branch. Drag a row in, past the edge to take it out.
--snapshot renders one frame of the real view tree to a PNG. Every screenshot on this page was made that way.
Get Crook
The script reads the latest release, checks the archive against the SHA256SUMS published beside it, and puts the binary in ~/.local/bin.
macOS
The image and the app are each signed, notarized and stapled, so the image opens with no warning. Drag Crook to Applications; its first launch asks once to confirm a download, and Open starts it.
Take the app rather than the bare binary: notifications, the dock’s badge and Default terminal need it.
Download the .dmgLinux
Debian 11, Ubuntu 20.04, RHEL 9 and anything since. --desktop also installs the desktop entry and icons that put Crook in the application menu.
curl -fsSL https://raw.githubusercontent.com/theguriev/crook/main/script/install | sh -s -- --desktopWindows
Built and tested on every change, but not yet run by anybody who works on Crook: there to try. It is unsigned, so SmartScreen asks once; More info, then Run anyway.
Download the .zipBuilding it yourself takes the Rust toolchain rust-toolchain.toml pins, and no build scripts. script/run starts it from the checkout and script/bundle makes the release binary; --snapshot draws a frame to a PNG without opening a window.