🐚 conch

An AI shell that learns your work and automates it β€” with your approval at every step.

Local-first. Everything it does is captured, reviewed, and auditable: from one-off commands to durable missions running across your machines.

$ curl -fsSL https://conch-site-gamma.vercel.app/install | sh

macOS & Linux Β· isolated install Β· no sudo Β· re-run to upgrade Β· v0.7.0 (changelog) Β· GitHub Β· read the script first

Examples

conch-ask prints one shell command for a request and never runs it; conch "…" runs a one-shot agent turn; /slash commands run inside a conch chat session. (The optional zsh widget in the repo's shell/conch.zsh puts the command on your prompt line instead β€” it is not part of this install.)

Ask for a command

Describe what you want; the exact command is printed for you to review, paste, or edit β€” nothing runs until you run it.

conch-ask "compress this folder but skip node_modules"
# β†’ tar --exclude=node_modules -czf archive.tgz .   (printed, not run)

Let the agent edit code safely

Sandbox the commands it runs and snapshot every edit β€” inspect the diff, and roll back in one step if you don't like it. Checkpoints live on conch-only refs and never touch your branch history.

/sandbox docker                 # run commands in an ephemeral container
conch "refactor the auth module and run the tests"
/checkpoint list                # per-turn snapshots of what changed
/undo                           # restore the worktree if needed

Run governed business workflows *

Plain-language operations over the Capitol gateway: steer runs from chat, compile a goal into a reviewed scheduled process, or draft a sandbox eBay listing from photos.

conch "backfill the funding intake for the first week of September"
/compile "triage inbound vendor invoices weekly"
/ebay photo.jpg -- pristine, original box

Durable missions, steered from your phone *

The edge daemon owns the mission through reboots; risky steps come back to you as approvals you answer from the Matrix/Slack/SMS thread. Fleet dispatch sends work to a trusted SSH worker.

/mission new "watch disk usage on burt and alert me before it fills"
# later, from the phone thread:  approve 3
/fleet run burt-1 "report uname -a and disk free"

* needs its component configured first β€” /install walks you through edge, fleet, and works.

Install / quick start

# one line (macOS & Linux)
curl -fsSL https://conch-site-gamma.vercel.app/install | sh

# uninstall
curl -fsSL https://conch-site-gamma.vercel.app/install | sh -s -- --uninstall

# from source instead
git clone https://github.com/detournement/conch && cd conch && ./install.sh

Uses uv or pipx when you have them, otherwise a private venv. No sudo. Windows isn't supported β€” WSL2 works via the Linux path. On first launch, conch walks you through picking a provider and pasting an API key (hidden input, stored 0600); the other components below are optional installs afterwards.

Capture β†’ compile β†’ operate

Conch turns work you already do into governed automation. Capture your real work (opt-in), let Conch mine the recurring shapes, compile a pattern into a reviewed Architecture Card, then operate it as a supervised workflow with approvals and an audit trail β€” locally, across your machines and channels, or through Capitol. Capitol pairs each exact executable workflow version with a readable, searchable Procedure (the SOP); the Card authorizes the design, while the Procedure documents what that pinned workflow does.

# turn on capture, then let conch find work worth automating
/install capture
/compile suggestions            # recurring shapes from your recent work
/compile from-suggestion 1      # β†’ a reviewed Architecture Card

Draft a card straight from a specific source:

/compile from-session                 # the conversation you just had
/compile from-mission <id>             # a durable mission's journal
/compile from-history 50 "nightly backup and prune"
/compile from-email                   # the capture mailbox
/compile from-scribe "Onboard a new vendor"   # a Scribe guide via MCP *
/compile from-procedure <workflow-id> --version 2
# exact existing Procedure + workflow version β†’ a draft Card

Browser capture β€” a Chrome extension records semantic clicks, navigation, and form-submit field names (never values, never passwords, never clipboard contents) on origins you explicitly allowlist, delivered to your local kernel over native messaging β€” no ports, no cloud. The extension ships inside the package, and setup creates a stable copy plus a native-host launcher that survives upgrades:

# set up the extension + native host, load it in Chrome,
# allowlist an origin in its options page β€” then:
/install capture browser
/compile from-browser example.com "automate this web procedure"

* Capture is opt-in (/install capture); compiling/operating processes needs the optional works module (/install works); from-scribe reads a Scribe workspace over MCP. Procedure commands require Capitol's ontology API rollout; before that backend epic deploys, they fail closed instead of compiling on read. Browser capture is proven first on Chrome for macOS; Linux host paths ship but are experimental until equivalently proven.

More examples

Operate machines on your network

Open a control connection to another box, run permission-gated commands over it, or ask for a tunnel.

/ssh connect thom@192.168.1.40
/ssh exec df -h /
conch-ask "forward local port 8081 to the llama.cpp box on my LAN"
# β†’ ssh -N -L 8081:192.168.1.226:8081 thom@192.168.1.226

Approval-gated malware sweep

An LLM-driven audit, not an antivirus: it proposes each hash, code-signature, and quarantine-flag check, and you approve every command before it runs.

conch "sweep ~/Downloads for suspicious binaries: hash them, check
code signatures and quarantine flags, and flag anything unsigned"

Components & capabilities

Conch starts as a local-first AI shell. Ask for a command and approve it before it runs, or open a full chat session that can execute shell, SSH, and MCP tools under graded permissions, with searchable conversations, memory, and cost tracking. It works with Anthropic (Claude, including Opus 5.5), OpenAI (including GPT-6 Sol and Luna), OpenRouter, Bedrock, a local Ollama, or any OpenAI-compatible server (llama.cpp, vLLM).

Its agent control plane carries approved work beyond one terminal: durable missions survive reboots and keep working across your machines, channels, and Capitol, with every risky step routed back to you as an approval. The shell is the base; everything else is an optional install from inside it.

shellinstalled first

The terminal UX: ask-mode, chat, tools, skills, memory, scheduling. This is what the one-liner installs.

curl -fsSL https://conch-site-gamma.vercel.app/install | sh

edge

An always-on personal daemon: durable missions, timers, approvals, and phone channels that keep running when the terminal closes.

/install edge

fleet

Trusted SSH machines as signed, bounded workers β€” a task plane with leases, retries, and artifacts.

/install fleet

works

An optional private module for governed Capitol processes: deterministic runs, reviewed Cards, exact-version Procedure/SOP linkage, and supervised missions. Existing Git/gh SSH access is used to install it; no bearer is put in package arguments.

It also ships skills for building frontend apps on Capitol β€” A2A agent consoles with live run progress and human-in-the-loop approval panels, workflow-fed pages, and REST/filestore portal apps. Each is scaffolded from a tested template, pinned to the workflow version it was built against, and verified headlessly against your gateway (agent card, run replay, deliverables) before the model edits anything. In conch: /skill capitol-frontend scaffold a console for the intake workflow.

What gets built: intake consoles that return a workflow's deliverables, public trackers fed by a scheduled run, deal-flow and opportunity portals over filestore records behind sign-in, approval consoles for human-in-the-loop checkpoints, status pages for email-triggered pipelines. When no workflow fits, the same skill drafts one for the compiler β€” /compile "…" β†’ review β†’ approve β†’ materialize β€” and wires the app to the version it created; nothing is created without your approval, and one command rolls it back.

/install works

capture

Opt-in, local-first: your sessions, missions, shell history, email β€” and, with the browser satellite, your allowlisted web work β€” become drafts the compiler turns into governed automations.

/install capture

Capabilities