Your terminal, with a coding agent inside.
Describe what you want in plain language. moh reads your code, edits files, runs commands — showing you every step and asking permission before anything risky.
curl -fsSL https://raw.githubusercontent.com/Marco-Cricchio/moh/main/scripts/install.sh | sh
brew install Marco-Cricchio/moh/moh
The installer verifies the sha256, installs to ~/.local/bin and upgrades in
place. The Homebrew formula installs the same checksummed release binary from
Marco-Cricchio/homebrew-moh. Then just run moh.
An illustrative session. The layout, glyphs, block grammar and colours are moh's real TUI (Tokyo Night theme), captured from the running binary.
Three things make it different
Not a fork. Not a wrapper. Yours.
moh is an independent, MIT-licensed agent you own end to end — no vendor account in the middle, no telemetry, no lock-in.
The provider you choose
Anthropic, OpenAI, Google, GitHub Copilot, OpenRouter, Kimi, xAI — plus OpenAI-compatible endpoints and local models. All through one config.
If one provider goes down, moh falls back to the next on your list. Your setup is never tied to a single vendor.
Your data stays yours
Sessions, memory and notes live as a plain append-only log under
~/.moh/ — on your machine. Nothing is silently rewritten, and
nothing about your usage is sent anywhere.
Resume, fork, rename, export, or move a session to another machine.
It asks before it acts
Layered permission rules gate every file write and every shell command:
y once, a always, e edit the call,
n deny.
Writes outside the project root are approved one at a time, every time. Extensions can veto a call — they can never grant more than you allowed.
Bring your own model
One agent, every backend
Built-in providers and OpenAI-compatible endpoints, plus local runtimes — switch with
/model, chain fallbacks per model, and set the thinking level per endpoint
(where available).
Vendor names are trademarks of their respective owners; listed for compatibility only. On the first run moh opens with a zero-credential mock provider, so you can look around before configuring anything.
What is in the box
Small enough to read, complete enough to live in
A headless core with a thin terminal client on top: the same engine drives the interactive TUI, scripts and CI.
Keyboard-driven TUI
Subagents, chips, live tool output, themes, thinking levels. Steer a running turn simply by typing.
Headless for CI
moh run executes a turn with no prompts and fails fast: a permission
prompt that cannot be raised denies the call instead of hanging.
Sessions that survive
Resume, fork, rename, and a trash that keeps deleted sessions recoverable. Handoff moves a session to another machine in one command.
Memory and compaction
Durable per-project facts written after each turn, and compaction that keeps long sessions usable without rewriting history.
Subagents and MCP
In-process subagents with strict tool inheritance, plus Model Context Protocol servers configured per project and loaded lazily.
Skills and workflow mode
Author your own skills, or turn on the bundled workflow:
/workflow on adds a port of the Matt Pocock agent workflow — plan,
spec, tickets, implement, review.
File and image mentions
Type @ for a fuzzy path picker; files, directories and images ride
along with the turn. Images preview inline where the terminal supports it.
Usage you can audit
moh usage reports calls, tokens, estimated cost, tool statistics and
route health — computed locally from your own logs, with no phone-home.
Extensible by design
Typed phase hooks, custom providers and an embeddable core library. An extension can veto a tool call; it can never widen your permissions.
Jev, an optional second opinion
moh can consult Jev — a TypeSafe service that answers with typed judgments, one probability or one choice per question, never text. It backs small decisions: the per-turn router, a prompt-injection check, prompt classification.
It is off unless you add a key, and every use case is a separate switch you own. The
anti-injection check is the only one that sends the text you typed, so it is never on
by default; /jev controls the use cases live, and the panel states
exactly what leaves your machine.
Model fallback, with or without Jev
When a model call fails — quota exhausted, rate limited, overloaded, network — moh moves to the next stop you configured instead of quietly swapping vendor.
The chain is derived automatically from your configured, fallback-eligible
endpoints, starting from the active one. Stops are concrete
endpoint/model-id references, never substitutions moh invents;
fallbackEligible: false excludes an endpoint, and a single provider
is simply a chain of one.
The per-turn router also chooses which of your models serves each turn.
Jev answers with a tier — economico, bilanciato,
potente — never a model id, and moh maps it to a model you actually
have. Nothing is invented, and if fewer than two tiers can be filled the router
stays inert. It is off by default; a manual /model pick pauses it and
auto hands it back.
Either way the switch is visible rather than silent: a toast names the stop, and the session log keeps the event, so a resumed session still shows what happened.
Project map (MPM)
The optional Moh Project Map builds a local, rebuildable structural view of your project — paths, symbols and provable relations, never copies of your source. moh uses it to orient a codebase task and to answer a model's focused query.
Advice is source-cited, and only ever at three confidence tiers: files the task
names, symbols it mentions, and (advisory, deliberately quiet) identifiers from the
model's own recent reasoning. An ambiguous match produces no advice at all. It is
opt-in, its background maintenance is built not to block a turn, and you can inspect
exactly what is mapped with /mpm or moh mpm.
How it compares
Independent, and honest about it
moh is not a fork or a clone — it is its own codebase, MIT licensed. Compared with the well-known terminal agents:
| moh | Claude Code | OpenAI Codex | OpenCode | |
|---|---|---|---|---|
| Providers | Any: Anthropic, OpenAI, Google, Copilot, OpenRouter, xAI, local — with per-model fallback chains | Anthropic only | OpenAI only | Multiple |
| License | MIT | Commercial | Commercial | Open source |
| Your data |
Append-only log in ~/.moh/ — resume, fork, rename, trash, export
|
Vendor-controlled | Vendor-controlled | Local |
| Permissions | Layered allow/ask/deny rules per tool and argument; out-of-root writes always re-ask; extension veto | Prompt-based approval | Prompt-based approval | Configurable |
| Headless | moh run — fail-fast, no prompts, CI-ready |
Yes | Yes | Yes |
| Extensibility | Typed phase hooks, skills, custom providers, embeddable core library | Skills / hooks | Limited | Extensions |
Vendor names are trademarks of their respective owners; the comparison is informational, based on publicly documented behavior.
Quick start
Running in about a minute
Install
macOS arm64/x64, Linux x64/arm64 and Windows through WSL. Self-contained: nothing else to install first — or use Homebrew if you already live there.
curl -fsSL https://raw.githubusercontent.com/Marco-Cricchio/moh/main/scripts/install.sh | sh
brew install Marco-Cricchio/moh/moh
Start it
The first run needs no accounts and no API keys — it opens with the mock provider.
moh
Connect a real model
A guided wizard: API key, or a subscription you already pay for (Claude Pro/Max, ChatGPT Plus/Pro, a personal Google account).
moh provider add
Questions
Answered straight
Is this a fork of something else?
No. moh is an independent codebase, MIT licensed, written from scratch — not a fork, a clone, or a thin wrapper around another agent.
Do I need Node, Bun or npm?
No. The binary is self-contained (the Bun runtime is embedded), verified by sha256 at install time, and upgrades in place when you re-run the installer.
Where does my data actually live?
Under ~/.moh/: one append-only event log per session, per-project memory,
and your configuration. The log is the session, so resume, fork and replay are
all projections of the same file — nothing is silently rewritten.
What is Jev, and is it required?
Jev is an optional second account moh can consult for small decisions — it returns typed judgments, never prose, so nothing about it can end up in what you read. moh works exactly as described without it: no key, no Jev. If you do enable it, each use case is a separate opt-in you can flip, and only the anti-injection check sends anything you typed — which is why it starts off.
Does it phone home?
No telemetry: nothing about your usage, prompts or code is sent to the project. Usage reports are computed locally from your own logs. The one thing that does reach the network on its own is the update check for new releases, and that is fully disableable.
What does it cost?
moh itself is free and MIT licensed. You pay whoever serves your model — or use a subscription you already have, or run local models through Ollama or LM Studio and pay nothing per token.
Which platforms are supported?
macOS arm64 and x64, Linux x64 and arm64, and Windows through WSL — inside WSL the installer installs the Linux binary, because moh ships no native Windows build. The installer refuses to guess on anything else.
Can I extend it?
Yes: typed phase hooks through the extension contract, your own skills, custom providers, or the headless core as a library inside your own application. Extensions can restrict the agent — veto a tool call or escalate it to a permission prompt — never grant more access than you configured.
Install it and try to break it
One command, no dependencies, nothing to sign up for. If it does not convince you in ten minutes, that is useful feedback too.
curl -fsSL https://raw.githubusercontent.com/Marco-Cricchio/moh/main/scripts/install.sh | sh