MaxiMind Code#

A coding agent in your terminal. Files, commands and approvals stay on your Mac; the model runs on MaxiMind's server.

What it is#

MaxiMind Code reads, searches and edits the files of the project you open it in, runs commands and tests, shows diffs and asks for approval, all on your computer. The model (Claude, GPT or Gemini) runs on MaxiMind's server. You sign in with your approved MaxiMind account; you never paste an API key or sign in to a provider.

Release 1.0.6, protocol 1, pinned Cline CLI 3.0.61 runtime.

Install, sign in, start#

curl -fsSL https://maximind.dev/install/code/macos | sh
maximind login

That is all: maximind login works in the same window (the installer links it into a folder on your PATH, or prints the full path to use), and after you approve the code MaxiMind Code opens straight away.

Later, type maximind anywhere. Outside a project it opens ~/MaxiMind, MaxiMind's home folder: just talk. Say "create a project called notes" and it makes ~/MaxiMind/notes (with git) and moves there at once; for a folder somewhere else ("open ~/Projects/my-app") you confirm in the terminal first. Started inside a project folder (cd ~/Projects/my-app && maximind), the window opens that project directly; maximind --here uses the current folder even if it is not a project. New versions install by themselves at start (from the next start; maximind config auto-update off stops it).

The installer verifies a signed release list and the release's SHA-256 and signature before unpacking into ~/.maximind/code, runs a self-test, writes the launcher ~/.maximind/bin/maximind and adds one marked PATH line to your shell startup file. It installs only inside your home folder and refuses to run as root. A no-pipe install and manual signature verification are in the install guide.

maximind doctor checks the installation, PATH, server connection, protocol and sign-in. maximind update, maximind update --check, maximind rollback and maximind uninstall do what they say; the first screen announces a newer release once a day.

Sign-in#

maximind login prints a short code and opens https://maximind.dev/api/code/devices/verify. Sign in with your MaxiMind Google account, enter the code, approve. The terminal stores one device credential in the macOS Keychain (service "MaxiMind Code"); it is never written to a file, log, shell history or command line.

• Only an approved, active account with the MaxiMind Code grant can approve a computer. Access is off by default; the owner enables people at /admin/code.
• maximind whoami shows the account and computer and renews an ageing credential (90-day expiry, rotated under 60 days). maximind logout revokes this computer.
• Manage or revoke your computers at /code/account.
• The credential works only on /api/code/*. It is not an API key and never an admin identity. A Canvas sign-in is not a Code sign-in.

Khoá API — sign in once, with a key#

For a machine nobody signs in on in a browser (a build server, CI, an assistant's Mac), the MaxiMind owner creates a MaxiMind Code key at /admin/code → Khoá MaxiMind Code: a name, an expiry (7, 30, 90, 180 or 365 days; 90 by default), the engines it may use (all by default), optionally a list of models (then only those models: an engine with none in the list is closed), and how many model requests it may run at once (1–12, 2 by default). The key (mmc_…) is shown once; MaxiMind keeps only its hash.

maximind login --key          # asks for the key (hidden), checks it with MaxiMind, stores it in the Keychain
maximind whoami               # Key: <name> · valid for N more days
export MAXIMIND_CODE_KEY=…    # or: use it without storing it (servers, CI)

• maximind login --key - reads the key from standard input; --key mmc_… also works but leaves it in your shell history. --to-file stores it in the private file instead of the Keychain, as for a device login.
• A key works only with MaxiMind Code (/api/code/*), never as an admin, and only with the engines and models its owner allowed: /models lists just those, asking for another one is refused with the reason, and maximind starts on an allowed model by itself. Web search runs only if the key allows Antigravity or Codex.
• A key sees public skills only, and cannot record model feedback in its owner's name.
• Every request rechecks the key: once the owner revokes it, or it expires, the next request is refused. Keys do not renew themselves; the owner makes a new one.
• maximind logout on a key machine only forgets the key there; the same key keeps working on its other machines until the owner revokes it.
• Usage is counted under the owner's account and shows per key, like a computer.

Permission modes#

Typing "yes" to the model never changes permissions. Each launch resets the approval toggle to that launch's mode.

The project boundary (every mode, including Full)#

• File reads and edits must resolve inside the project folder after symlinks. ../, absolute paths elsewhere and symlink escapes are refused.
• Secret files are refused even inside the project: .env and .env.* (except .env.example|sample|template|dist), private keys, .pem/.key/.p12, .netrc, .npmrc, .pypirc, .git-credentials, credentials.json, secrets.*, and .ssh/.aws/.gnupg/.kube/.docker/.maximind folders.
• Web fetches must be public http(s) pages; local, private and link-local addresses are refused.
• Commands are filtered, not sandboxed: sudo/doas/su, Keychain and credential access, secret files, environment dumps, piping text into a shell, eval and decode-and-run are refused. A shell command is run by a real shell, so the filter is best-effort; commands are not confined to the project folder. The real control is Ask mode.
• Tool results are scrubbed of credential-shaped values before they leave the computer. Unknown or malformed tools are refused.

Inside the terminal#

Type / for the command menu: /model (picker grouped Claude, Codex, Antigravity, Auto), /models (live catalogue; denied models never listed), /permissions, /whereami, /status (connection, account, last model, fallback events, quota note), /history, /resume, /new, /compact, /workers, /login, /logout, /help. The default model is claude/opus.

Escape stops the current turn; Ctrl+C exits when idle. MaxiMind does not display a model's private chain-of-thought. Token and cost counters in the footer are not quota measurements: the providers do not report remaining quota.

Workers (researcher, coder, tester, reviewer) use this window's project folder, model, approval mode and boundary, and run one after another.

Several windows#

Each terminal window has its own conversation, model, permissions and state folder. Model capacity is shared with every MaxiMind window and user. The server admits up to 12 active model requests per person across all windows; a request beyond that waits up to three minutes for a free slot. Two windows in the same folder get a warning; maximind --worktree <name> creates a git worktree for independent parallel work, after asking.

Headless and parallel agents#

Another program — a script, or an AI such as Claude Code — can run MaxiMind Code agents without the full-screen interface and run several at once. Tested 2026-09-25: three agents in parallel, each finished its task in its own folder, and the work was spread over two Antigravity accounts.

maximind --cwd ~/Projects/app-worktree-1 --permissions full --json --model agy/gemini-4-argon-high \
  "Add input validation to signup.py and run its tests." < /dev/null > events.jsonl 2> stderr.txt

• --json runs the request without the interface and writes one JSON event per line; the last event with "type": "run_result" holds the agent's final answer in text. Exit code 0 means the run finished.
• --permissions full approves tools for this launch only, so nobody has to press yes. The project boundary still applies: reads and edits only inside --cwd, secret files refused, commands filtered but not sandboxed. Without it a headless run cannot be approved.
• Give each parallel agent its own folder — a git worktree per agent (git worktree add ../app-a1 -b a1) — and review its diff before merging. --worktree asks a question, so a script creates worktrees itself.
• Up to 12 model requests per person run at once across every window, Chat and the API; an agent makes one request at a time, so about 6–8 agents at once leaves room for your own windows.
• Which subscription account answers is decided by MaxiMind: work spreads over free accounts and moves on when one runs out. Name the model, never an account.
• Models that edit files as agents (tested): agy/gemini-3.8-flash-high (fastest), agy/gemini-4-argon-high (since 13/10/2026 it also answers for the old agy/gemini-3.1-pro-high; editing through MaxiMind Code was tested with the old model, not re-tested with Argon yet), agy/claude-sonnet-4-6, agy/claude-opus-4-6-thinking, claude/opus. Codex models (codex/…) answer questions but do not edit files as agents yet — they treat the server's read-only sandbox as your project.
• A line on stderr about providerOptions key 'openai-compatible' is a harmless runtime warning.

Network inside the agent#

The pinned runtime is started behind a small local pass-through filter that refuses its vendor telemetry hosts (*.cline.bot, models.dev, *.i.posthog.com), literal localhost targets and link-local addresses; everything else is tunnelled untouched, TLS never intercepted. Commands the agent runs inherit the filter. A plain http:// proxy from your environment is chained; https:// or SOCKS proxies are bypassed inside the agent.

The Code API#

Used only by the maximind client. Clients send X-MaxiMind-Code-Protocol: 1; an unsupported value gets 426 ("run maximind update"). All responses are private, no-store.

curl -s https://maximind.dev/api/code/protocol

{"protocol": 1, "supported": [1]}

Errors#

Guides#

• Install, update, rollback, uninstall, troubleshooting: /docs/code-install.md (repository: docs/CODE-INSTALL.md).
• Release notes and what to do per version: /docs/code-releases.md (repository: docs/CODE-RELEASES.md).
• Full terminal guide: repository docs/MAXIMIND-TERMINAL-AGENT.md.
• Owner and user administration, credentials, metering, publishing: repository docs/CODE-ADMIN.md.

Talking first, projects later#

A window outside a project works in a private scratch space, so nothing is written where you are standing. Opening a project moves it into that folder, which is then the only place it reads or writes; system folders, your whole home folder and folders holding settings or secrets are refused. The earlier part of the conversation stays in /history; the new folder starts with a summary of it, so the model knows what you were doing. For a single answer that closes the window afterwards: maximind ask "how does TLS work?".

Long conversations#

MaxiMind Code summarises the older part of a long conversation by itself and keeps going; /compact does it on demand. If a request still arrives too large, MaxiMind shortens old tool output and drops the oldest steps rather than refusing — your first request and the newest steps are kept, and the model is told the middle was compacted. Claude models hold roughly four times more of a conversation than the Codex and Antigravity ones.

When a window closes#

MaxiMind Code asks one key — did it work? yes / partly / no / Enter to skip — and sends a counts-only report to MaxiMind: how many requests, cancelled turns, tool calls and project-boundary refusals the window saw, which models answered, and your answer. It never sends prompts, files, paths or commands. The owner uses it to see where Code fails people.