Quil

The persistent workflow orchestrator for AI-native development.

A terminal multiplexer built for developers who orchestrate 5–10 sessions per project across AI assistants, build watchers, webhook tunnels, and SSH connections. Unlike tmux, Quil understands projects and typed panes: it persists your entire workspace across reboots, auto-resumes AI conversations by session id, and lets your AI assistant drive your terminal over MCP.

Type quil after a reboot — every tab, pane, working directory, layout split, and AI conversation is right where you left it.

Survives a full reboot	AI drives your terminal
Panes, working dirs, and AI sessions snap back in ~30s.	Expose Quil over MCP — agents list panes, read output, send keys.
Many projects, one window	Typed panes
Focus mode + a dozen project tabs.	Per-type setup: dir browser, resume strategy, permission toggles.
Resize with the mouse	Right-click pane menu
Drag any split border — nested panes clamp to minimums, PTYs see one resize on release.	Per-pane actions under the cursor: history, notes, lazygit, attention pin, restart, close.
Command palette: jump anywhere	…and run anything
Alt+Shift+P fuzzy-finds every pane and tab — navigation grouped at the top.	Every action grouped below, each showing its keybinding; type to filter instantly.
…and search inside every pane	Jump to the match
Start typing and the palette also searches every loaded pane's scrollback — match counts + a preview under Found in panes.	Enter on a pane match jumps straight to it. Searches loaded panes; lazily-restored panes appear once you open them.
Every project in one sidebar	…including ones on other machines
Projects group tabs and roll up their agents — ⚠ needs you, ◐ working, ✓ finished while you were elsewhere. Per-pane git branch underneath.	A remote host is a sibling row with its host under the name. Its panes run over there; the sidebar reports them exactly like local ones.

Linux / macOS — one-line install (detects OS+arch, verifies SHA-256):

curl -sSfL https://raw.githubusercontent.com/artyomsv/quil/master/scripts/install.sh | sh

Windows — download quil-windows-amd64.zip from Releases, extract anywhere on PATH.

Go users:

go install github.com/artyomsv/quil/cmd/quil@latest
go install github.com/artyomsv/quil/cmd/quild@latest

Full install options + build-from-source — see docs/installation.md.

quil          # launches the TUI, auto-starts the daemon

Five keys to remember:

That's enough to start. See docs/quick-start.md for the first-launch walkthrough and docs/keybindings.md for the full keymap.

If anything ever hangs: quil restart recovers the daemon (escalating stop → fresh start → tabs restored from the last snapshot), and Alt+R restarts a single stuck pane in place with its AI session resumed.

A project groups tabs, owns a root directory, and belongs to one daemon. Alt+Shift+S opens a sidebar listing all of them at once, and that is the point: an agent that finished — or got stuck asking you something — in a project you are not looking at is visible from the one you are.

Each project row rolls up its panes: ⚠ blocked on you, ◐ working, ✓ finished while you were elsewhere. Blocked and finished are different states, because they need different things from you. Alt+Shift+A jumps to whichever agent has been waiting longest anywhere in the workspace — oldest first rather than sidebar order, since that is the one costing you time.

Under the active project each pane also shows the checkout it sits in — branch, wt for a linked worktree, ↑N/↓N against upstream. Cached per checkout, so ten panes in one repository cost one git invocation, and a probe that does not answer keeps its last value marked stale rather than guessing.

Existing workspaces migrate on first load into a single project named Default, tab order preserved — no prompt, nothing to opt into. Full detail in docs/features.md.

quil --remote gpu01

The machine doing the work and the machine you sit at are increasingly not the same one — a GPU box, a cluster node, a beefy desktop reached from a laptop. An AI agent mid-task is exactly the workload you least want tied to a laptop lid.

flowchart LR
    subgraph laptop["your laptop"]
        TUI["quil<br/><i>a viewer — holds no state</i>"]
    end
    subgraph host["gpu01"]
        D["quild"]
        P1["claude"]
        P2["shell"]
        P3["lazygit"]
        D --> P1
        D --> P2
        D --> P3
    end
    TUI -->|"ssh -T · one channel · no open port"| D

No port is opened on the remote. Quil runs ssh -T gpu01 "quil --stdio" and speaks its normal protocol over that single channel, so anything SSH reaches works — a bastion behind ProxyJump, a Tailscale address, a box on the public internet. The destination goes to ssh verbatim, so your ~/.ssh/config keeps working: Host aliases, jump hosts, per-host keys, hardware tokens, certificates.

The server needs nothing installed first. Point --remote at a bare machine and it offers to install one, then attaches. Your laptop downloads the release for the remote's platform and pushes it over the connection you already have, so a node with no route to GitHub provisions as easily as one with.

Or add the host without leaving the TUI. Tick Remote (ssh) in the New Project dialog and press Enter on the Host row — Quil dials it, installs or upgrades Quil there if it needs to, then browses that machine's filesystem for the root directory:

Dialling, and provisioning what it finds	Connected — now browsing the remote disk
The one message line is coloured by what it means — red only when the host cannot be reached at all, amber while work is under way.	Green once the link is up. The directory list comes from the server, so ~, relative paths and drive roots all describe the right machine.

A dropped link is a pause, not an ending. Close the lid, lose wifi, change network — an amber bar names the host, counts the attempts, and shows what ssh said, retrying with backoff until it lands. The panes never stopped, so there is nothing to resume. Keystrokes are dropped rather than queued while the link is down: a key typed at a dead connection would otherwise arrive minutes later in a live agent session, answering a question that had already moved on.

Every dialog describes the server, not your laptop. The working-directory picker, ~, relative paths, drive and root listings, git-repository discovery, kube contexts, which tools are installed, and the recent-directories list all ask the daemon. Before that, Alt+G could report no repository in a directory where the agent in that very pane answered git status with the branch name.

Beta, and honest about it: plugin definitions still come from your local machine, the daemon detects installed tools only at startup and on plugin reload, quil status and the update controls refuse rather than retargeting, and remotes must be Linux or macOS. Details and the roadmap are in docs/features.md.

Add this to your AI client's MCP config (Claude Desktop, Claude Code, Cursor, VS Code Copilot):

{
  "mcpServers": {
    "quil": {
      "command": "quil",
      "args": ["mcp"]
    }
  }
}

Restart the client. The AI can now list_panes, read_pane_output, send_to_pane, watch_notifications, screenshot_pane, and 12 more tools. Read the build pane and react to errors without copy-paste.

Full guide: docs/mcp.md.

Typed panes ship for the tools developers run all day. Each opens from Ctrl+N; the ones that wrap an external binary appear only when that binary is on PATH (greyed with an install link otherwise).

Define your own pane types in TOML — see the plugin reference.

The full doc index lives at docs/README.md.

See CONTRIBUTING.md for branch / commit conventions and the development workflow. Bug reports and PRs welcome.

MIT — Copyright (c) 2026 Artjoms Stukans

The Windows build bundles Microsoft's MIT-licensed OpenConsole (OpenConsole.exe + conpty.dll) to host terminal panes correctly on Windows 10. See THIRD_PARTY_LICENSES.md for full third-party attribution.