English · 简体中文

Help coding models write better code and finish faster with better context, reusable experience, and verified results.

Why Metis · Coding performance · Reliability · Quick start

---

Quick start

Choose one interface. Both use the same Metis configuration, models, and sessions.

Interface	Best for	Requirement
Desktop app	Graphical workspace with CLI and server included	Apple silicon Mac (arm64) or Windows (x64)
CLI	Terminal, scripts, print/JSON, RPC, and SDK integrations	Node.js >=22.19.0 and npm

Desktop app for macOS

1. Download the latest Apple silicon .dmg (Metis-*-macos-arm64.dmg).
2. Open it and drag Metis.app into Applications.
3. Launch Metis. Node.js is already included.

Desktop app for Windows

The Windows build bundles the full Metis CLI and server runtime. Choose the setup EXE for a normal installation or the ZIP for a portable copy.

Current build: Windows x64. No separate Node.js installation is required.

1. Open the latest GitHub Release.
2. Download and run Metis-*-win-x64-setup.exe, or download Metis-*-win-x64.zip, extract it, and launch Metis.exe from the Metis folder.
3. Use the attached .sha256 file to verify your download. If Windows SmartScreen warns about an unknown publisher, continue only when the file came from the official release page.

CLI and terminal

Install Metis, then start an interactive session:

npm install -g --ignore-scripts @wholiver_hu/metis@latest
metis

Run metis --help to view every CLI option.

Why Metis

Metis is an agent layer for coding models. It does not replace the model or change its weights. It improves the model's effective coding performance by giving it a better way to search, remember, work, and check its own result.

That means better repository understanding, fewer unsupported assumptions and missed requirements, stronger task completion, and less time spent repeating context.

Better coding performance

For the same underlying model, Metis strengthens the system around it:

• Relevant context — search the repository and authoritative sources before editing.
• Reusable experience — carry useful decisions, lessons, and technical knowledge into later work.
• Evidence-based implementation — follow existing code, constraints, and project conventions instead of guessing.
• Verified completion — build, test, inspect output, and compare the result with the original request.

These mechanisms can improve practical coding outcomes without retraining or replacing the model. Results still depend on the model, task, tools, and environment.

Faster completion

In one user test with the same task:

• Metis finished in 1 minute 30 seconds.
• OpenCode finished in 3 minutes 30 seconds.
• No accuracy difference was observed in that test.

Metis used about 57% less time in this comparison. This is one user test, not a universal benchmark; results depend on the task, model, tools, and environment.

What makes it reliable

Memory and Lessons

Metis checks its brain map before starting technical work. It can reuse relevant decisions, project knowledge, and technical lessons from earlier sessions instead of rediscovering them every time.

During long tasks, Metis keeps an append-only working log with compact checkpoints, diagnosed errors, verification state, and next steps. It restores the latest state after resume, interruption, or context compaction; Dream later consolidates the complete history.

Dream

Dream reviews completed work and consolidates useful notes into structured memories and lessons. Temporary task context becomes reusable knowledge, while low-value details can be cleaned up.

Search before action

Metis investigates before making changes. It searches the repository first and uses web research when needed to check authoritative documentation, known solutions, release notes, or security information.

Logs and verification

Metis records meaningful errors and completion summaries. Before it says a task is finished, it compares the result with the user's original prompt and checks every requirement, constraint, and later clarification. It also runs relevant builds, tests, and functional checks when available.

Together, these behaviors help the same coding model work with better context, fewer assumptions, and a stronger completion loop.

How it works

1. Understand — read the request, recall relevant lessons, and investigate the codebase.
2. Build — make focused changes and keep a useful work record.
3. Verify — test the result and compare it with the original request.

Developer information

Interfaces

Metis supports an interactive terminal, print and JSON output, RPC integration, and an SDK for Node.js applications.

The package exports the SDK from @wholiver_hu/metis and the RPC entry point from @wholiver_hu/metis/rpc-entry.

Commands

Command	Purpose
npm run build	Compile TypeScript and copy runtime assets.
npm test	Run the Vitest test suite.
npm run clean	Remove compiled output.
npm run build:binary	Build the standalone binary.

Contributing

Contributions are welcome. See CONTRIBUTING.md for core development, Extension integration, Package distribution, testing, and AI-assisted contribution guidance.

License

Distributed under the MIT License.