MOMO CODE
An AI coding agent that evolves with you: a dual-speed self-evolution system combining second-level experience injection with hour-level weight fine-tuning.
Trust: Credit — the LICENSE is MIT with an explicit derivative-work notice attributing opencode (SST), so source attribution is thorough and earns full marks. Human-approval gates for /refine and /optim semantics are documented and partially test-corroborated (approval flow implied), scoring adequate. Least privilege, dependency security, and sensitive-data handling all lack in-scope evidence: no lockfile or dependency audit, and the claimed permission system and 'Secret Scrubbing' appear only as prose (a scrubbed field in test fixtures is the sole trace), so deductions. External effects are broad — a curl|bash installer edits shell rc files, a daemon runs autonomously, and /sim executes LLM-generated Python — with little shown in the way of guards; heavily deducted. Rollback is reasonable: uninstall instructions, /graph resume, and --dry-run flags are documented.
Reliability: Deducted — self-consistency is poor: the README claims v1.0.0, '17/17 tests passed', and 53 modules, while package. says 0.1.1 and only 3 test files are in scope; dates read 2026 (future), creating contradictions. Dependency availability is adequate: CI (ci.yml, build.yml) runs typecheck/build/test and prerequisites (Node≥20, optional Python packages) are stated. Failure messaging is adequate: /sim doctor, INSTALL.md troubleshooting, and PATH-fix guidance exist.
Adaptability: Audience and scenarios (Effect enthusiasts, Claude Code migrators, long-running tasks) are clearly laid out in README and test comments; toggles and triggers (MOMO_NO_CC_SWITCH, MOMO_CLAUDE_CODE_INHERIT, inherit defaults ON with opt-out) are test-corroborated. Capability boundaries are almost undocumented — self-evolution, MCGS, and LoRA claims carry no stated limits or in-scope evidence, a major deduction. Environment fit is adequate (macOS/Linux/WSL, version checks).
Convention: Information architecture is excellent (TOC, architecture diagrams, layered project layout, full env-var tables) and install notes are thorough including uninstall and troubleshooting — both full marks. Deducted: naming instability (kqq Code → momo Code rename, inconsistent casing, version mismatch); no known-limitations section; the changelog lives only in README and conflicts with package.; maintenance responsibility rests on a SECURITY.md and an unverifiable email with an unknown publisher. The license file itself is complete (MIT + derivative notice), but registry metadata is NOASSERTION and NOTICE/USE_RESTRICTIONS.md referenced in README are absent, so license scores adequate not full.
Effectiveness: Output usability is adequate — CLI help works without an API key (test-covered) and model tiers are documented. Marginal value: the dual-speed evolution, /graph, and /optim features differentiate from upstream opencode and are concretely described, but none are executable-verified, so the value claim remains unproven. Cost/benefit is adequate: budget rails (MOMO_EVOLVE_BUDGET_USD, MOMO_RLM_BUDGET, MOMO_DAEMON_MAX_HOURS) are documented.
Verifiability: Deducted — claim traceability is weak: assertions like '25+ providers', '53 modules', '17/17 tests passed', and '0 errors' cannot be supported by the evidence provided (only 3 test files in scope); fact and inference/marketing are mixed, including an invalid arXiv link (2604.09791) and future dates. Cross-source corroboration is adequate: CI workflows and the cc-switch/bridge tests partially substantiate README claims about inheritance and promotion mechanics.
- Version (1.0.0) and test claims (17/17) in the README conflict with package. (0.1.1) and the number of test files actually present; the cited arXiv link is malformed and dates read 2026 — treat proof-of-quality claims as unverified.
- The recommended install is a curl|bash remote script that clones the repo and rewrites PATH in ~/.zshrc/~/.bashrc; audit the script before running it.
- The permission system (allow/deny/ask), Secret Scrubbing, and telemetry opt-in are asserted in SECURITY.md but not evidenced in the provided source; verify sandboxing and approval logic yourself before using /evolve, /fine-tune, or /sim (which executes LLM-generated Python).
- /daemon and /schedule support hours-long autonomous operation with goals injected into every session; run in isolation and configure the budget rails.
- License metadata is NOASSERTION and NOTICE / USE_RESTRICTIONS.md referenced in the README are absent; complete third-party attribution review before compliance sign-off.
What does this agent do, and when should you use it?
MOMO CODE is a terminal-based AI coding agent CLI built on opencode, whose defining feature is a dual-speed self-evolution system based on the Pioneer Agent paper. The fast loop (`/evolve`) distills successful patterns into Tactic cards in seconds via the KEP protocol, selecting them with Thompson sampling and injecting them into the system prompt; the slow loop (`/fine-tune`) improves model weights at hour scale through Monte Carlo Graph Search (MCGS) plus LoRA. It supports 25+ LLM providers (DeepSeek, Zhipu GLM, Moonshot Kimi, Claude, GPT-4, Gemini, etc.) and any OpenAI-compatible custom API, with zero-config ultra/standard/lite model tiers. Beyond coding sessions it ships recursive subagents (/agent), a resumable DAG graph engine (/graph), long-running goals and a daemon (/goal, /daemon), a Genesis physics simulation agent (/sim), reasoning-driven parameter optimization (/optim), voice input (/voice), and a local server with dashboard (serve). All state lives locally under ~/.momo/ and code never leaves your machine. Current release is v1.0.0; the README states an MIT license, though GitHub metadata reports NOASSERTION, so verify before adopting.
After installation, run momo for an interactive session or momo "task" for one-shot execution. It reads signals from session trajectories (test pass/fail, edits accepted/rejected, user corrections); in /evolve it distills successful patterns into Tactic cards, tracks Beta distributions, selects via Thompson sampling or UCB1, injects top tactics into the system prompt, and updates stats with --solidify; high-confidence tactics promote into the /fine-tune curriculum. /fine-tune runs signal mining, curriculum synthesis, MCGS pipeline search, LoRA fine-tuning, and a ratchet gate. /agent decomposes a task into parallel child momo processes with a synthesis pass; /graph plans a resumable DAG executed level-by-level with retries; /sim drives a persistent Genesis physics world through a long-lived Python process where the model emits thought/code executed in a persistent namespace; /optim reads your code first, infers parameter semantics, then runs a tuning loop with explicit _reasoning; serve exposes a JSON API + SSE feed and single-file dashboard at 127.0.0.1:4097. Configuration lives in ~/.momo/momo.c with MOMO_* env overrides for keys and budget rails (e.g. MOMO_RLM_MAX_DEPTH=3, MOMO_RLM_BUDGET=8).
- Developers who want their coding agent to accumulate project-specific experience over time — the /evolve tactic library records and reuses winning strategies.
- Users migrating from Claude Code — config inheritance (on by default) merges ~/.claude/settings., MCP servers, and prompts automatically.
- Engineers decomposing large refactors (e.g. refactoring the provider layer plus all callers and tests) for parallel execution via /agent or /graph.
- Teams needing unattended multi-hour work such as scheduled test runs and release goals — combine /goal, /schedule, /heartbeat, and /daemon.
- Robotics/embodied-AI researchers who want an LLM to control a Genesis physics world — use /sim run for control loops with recorded trajectories.
- Engineers tuning service parameters (thresholds, budgets) with auditable reasoning traces — use /optim with an evaluation command as feedback.
What are this agent's strengths and limitations?
- The dual-speed evolution architecture is a real differentiator: /evolve's second-level prompt injection (Thompson sampling over tactics) bridges into /fine-tune's hour-level LoRA training, and promoted tactics become the training curriculum.
- Provider-agnostic: 25+ built-in providers plus any OpenAI-compatible API via MOMO_CUSTOM_* env vars, with zero-config ultra/standard/lite tier switching.
- Near-zero migration cost for Claude Code users: settings., MCP servers, and prompts are inherited by default, and can be disabled via env vars.
- Local-first with safety rails: code stays on your machine; /refine proposals require human approval; recursion depth, subagent budgets, and training spend (MOMO_EVOLVE_BUDGET_USD) are all capped.
- No npm package in v1.0 — installation requires cloning and building locally, with official support only for macOS/Linux (Windows needs WSL).
- Advanced features depend on external components: /sim needs Python + genesis-world, /voice needs sounddevice, scipy, and an OpenAI-compatible STT endpoint, and /daemon must be backgrounded yourself with nohup/systemd.
- LoRA fine-tuning via /fine-tune has real monetary cost (default budget cap of USD 50) and requires correctly configured training credentials.
- GitHub metadata lists the license as NOASSERTION, conflicting with the README's MIT claim — review LICENSE, NOTICE, USE_RESTRICTIONS.md, and SECURITY.md before commercial use.
How do you install or deploy this agent?
Prerequisites: macOS or Linux (Windows via WSL), Node.js >= 20, git, curl. Recommended install:
curl -fsSL https://momozi.cc/install | bashThe installer clones the repo to ~/.momo/lib/momo-code, runs npm install + npm run build (~30-60 s), drops a wrapper at ~/.momo/bin/momo, and adds it to your PATH. Open a new terminal and verify with momo --version. Manual from source:
git clone https://github.com/momozi1996/momo-code.git
cd momo-code/packages/opencode
npm install
npm run build
node bin/momo --versionThe npm package is planned for v1.1 and unavailable in v1.0. Uninstall: rm -rf ~/.momo and remove the PATH line from your shell rc.
How do you use this agent?
- Set credentials:
export MOMO_API_KEY=your-key, or provider-specific keys likeMOMO_ANTHROPIC_API_KEY/MOMO_OPENAI_API_KEY. 2. Run: interactive mode withmomo; one-shot withmomo "Refactor auth to use Effect"; pick a tier withmomo --model ultra "Complex architecture review"(ultra/standard/lite). 3. Key commands:momo /evolve --injectto inject learned tactics,momo /fine-tune run --dry-runto preview training,momo /refineto generate human-approved improvement proposals,momo /graph run "Design + implement + test a persistence layer"for DAG orchestration,momo servefor the local dashboard (default http://127.0.0.1:4097). Configuration goes in ~/.momo/momo.c with options like inheritClaudeCode and evolve.budgetUSD.
How does this agent compare with similar options?
The README states the project is built on opencode and offers a seamless migration path from Claude Code (inheriting .claude/ config, MCP servers, and prompts). Compared to Claude Code, MOMO CODE's differentiator is its built-in /evolve experience fast loop and /fine-tune weight slow loop; if self-evolution is not needed, the more mature ecosystems of Claude Code or upstream opencode may be safer choices.