The AI agent that proves it's done.

See it work

It gets it wrong. Then it proves it got it right.

motita adds a --json flag to a small CLI. The first try doesn't compile, the real check catches it, and the second try passes.

Replayed from a real run — the commands, the error and the report are the ones in the screenshots below.

A tour of the real thing

Nothing here is a mock-up. It's the app.

The same binary gives you a browser app, a phone app and a terminal app. Every screen below was captured from motita running that task.

The reportEvidence, not adjectives Its thinkingWatch the plan form Every commandNothing happens in secret It asks firstWhen it matters In your terminalSame agent, keyboard-first One-minute setupFive questions, done

motita · Add JSON output to notes

What you can hand it

From a one-line fix to a whole afternoon of work.

Describe the outcome. motita works out the steps, runs them, and keeps going until your project's own check agrees.

Bring your own AI

Your subscription, or any API. Your choice.

Sign in with the account you already pay for, or paste a key. Logins renew themselves before they expire, and keys are stored 0600, never in the config. Switch any time with /models — nothing else in the agent cares which one is behind it.

Your repository stays yours

Every conversation on its own branch.

Point motita at a repository and each session works in a git worktree of its own, on branch motita/<session>. Your checkout is never the one being edited, and two sessions never step on each other.

# Ctrl+G or /agents in the terminal; the AGENTS drawer in the browser
Agents  1 running · 48.2k tok
 /  main · fix the session export     2m14s   31.0k tok  r12
 /  write the export tests             1m02s   11.9k tok  r6   running: go test ./internal/export
 √  update the reference               0m48s    5.3k tok  r4   motita/sub/…-a2 · 1 file changed

Safety

Fast where it's safe. Asks where it isn't.

A guardrail that interrupts you for make gets switched off within a week. So motita runs the everyday work silently, stops for anything that reaches past your project, and has a floor of commands it refuses no matter what — with no flag, key or variable that relaxes it.

ALLOW It changes nothing, or only the workspace you pointed it at. make, go build, npm test and your own ./scripts/* run silently.

ASK It reaches the network or the system, writes outside the workspace, or can't be classified. You are asked before anything runs — once, or for the whole session.

DENY The floor, always: mkfs, partition editors, dd with an output, the power verbs, and rm/mv/cp/ln aimed at /, ~, a system path, or the tree that contains your workspace.

an ASK, live

Plan mode is structurally read-only. It calls tools through a path that never invokes a shell, so pipes, redirections and metacharacters aren't blocked — they're syntactically unreachable. And the browser link carries its token in the URL fragment, traded once for a cookie holding an HMAC of it.

It gets better with you

It learns from you, not from a retraining pipeline.

A library of procedures: how a kind of work is done, the commands that work, the pitfalls someone already paid for. Eight ship inside the binary, the agent writes new ones when it learns something, and a project can keep its own. They are files — read them, fix them, version them.

• /good and /bad land on the procedures a turn actually used, and the library is searched by what has worked before. No fine-tuning, no extra bill.
• A curator keeps the shelf tidy without a model: unused procedures are marked stale, then archived — never deleted — and a pinned one is never touched.
• Retries that learn something: a failed check sends back the command, its real output and a structured verdict, so the next attempt fixes the actual problem instead of re-rolling the dice.

Running it

One binary: configure it, run it, serve it, script it.

After the installer, the binary is the whole program: the terminal interface, the gateway and the browser page are the same file. With no configuration on the machine, the first run launches the wizard — and the step no other agent makes you answer is the anchor: the command that proves a task is really done.

# the wizard: provider → connect → model → check → review
motita config

# or just start it — with no config found, the wizard runs itself
motita

# no arguments: a gateway is started for this interface, in-process
motita

# one-shot, scriptable: exit 0 when the check passed, 1 when not
motita -task "fix the failing test in internal/policy"
motita -p "how many files are there?"

The gateway, every setting and the exit codes are in the reference.

Built like it matters

Tested the way you'd test something you were about to bet on.

These are measured, not asserted — and the documentation's claims are anchored to the code by tests, so this page cannot drift away from the behaviour.

CI reads the ELF header to prove the i386 binary really is 32-bit, runs the end-to-end tests inside a real 32-bit container, and runs staticcheck and govulncheck before publishing anything. Pure Go, standard library only: no cgo, nothing to vendor, nothing to patch.