Metis is a high performance and personal AI assistant which is build with Cangjie program language. And this project is based on magic-cli and CangjeMagic.

It combines an interactive CLI, a unified Gateway-first runtime, channel adapters, skills, persistent sessions, and operational surfaces for running agents in real workflows instead of one-off chat demos. Supported channels include: Telegram, QQ, Feishu.

Metis is designed around one practical idea: the same agent runtime should be able to serve local CLI conversations, managed sessions, gateway APIs, and IM channels without splitting product behavior across unrelated code paths.

That gives the project a few defining characteristics:

• Gateway-first runtime for default chat, automation, and channel delivery paths
• Cangjie-based agent implementation with Cangjie Magic integration
• Interactive CLI for development, debugging, and daily use
• Skills system built on SKILL.md packages with workspace and user-level discovery
• MCP integration for external tools and service extension
• Persistent conversations, transcript-backed sessions, and workspace memory
• Cron scheduling for recurring agent tasks
• Channel delivery for Feishu, QQ, Telegram, and plugin-driven IM integrations
• Control and observability surfaces for dashboard, HTTP, and runtime inspection

Without undergoing any specialized performance optimization, Metis has achieved a more than 20-fold leap in startup and shutdown efficiency compared with vendor baseline in the measured baseline scenario.

Absent any specialized performance optimization, Metis has realized a qualitative leap in its startup and shutdown efficiency:

The detailed data is presented below; notably, these figures were achieved without any performance optimizations whatsoever (perhaps because Metis's feature set is not yet fully comprehensive?).

Test Environment:

• MacBook Air 2026 M5 (10-core CPU + 10-core GPU) | 16GB RAM + 256GB SSD
• macOS 26.4 (25E246)

Metis is a source-first Cangjie project. Start from the core dependencies, build once, then install optional feature dependencies only when you use those features.

# Cangjie SDK
export CANGJIE_HOME="/path/to/cangjie-sdk-1.0.0"
source "$CANGJIE_HOME/envsetup.sh"

# CangjieMagic dependency used by cjpm.toml
export MAGIC_PATH="/path/to/CangjieMagic"

# stdx TLS/OpenSSL runtime on macOS
brew install openssl@3
export DYLD_LIBRARY_PATH="/opt/homebrew/opt/openssl@3/lib:$DYLD_LIBRARY_PATH"

# macOS SDK used by the Cangjie build/link step
export SDKROOT="/path/to/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk"

cd "$MAGIC_PATH"
cjpm clean
cjpm build -i

cd /path/to/Metis
cjpm clean
cjpm build -i
cjpm test --parallel 1

The build can pass without model or IM credentials, but real conversations need provider configuration under ~/.metis/metis.json.

Run the onboarding flow for first-time setup:

cjpm run --skip-build --name metis --run-args "onboard"

At minimum, configure one chat model provider, for example qwen, deepseek, openai, or another provider supported by the model catalog:

{
  "models": {
    "providers": {
      "qwen": {
        "apiKey": "<your-api-key>",
        "baseUrl": "https://coding.dashscope.aliyuncs.com/v1"
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "qwen/qwen3.6-plus"
      }
    }
  }
}

For Telegram image understanding, configure a dedicated image model whose model catalog input includes image. Qwen qwen/qwen3.6-plus is built in as text,image; unknown custom models must declare input metadata under models.providers.<provider>.models[] or gateway.media.image.models[].

IM channels need their own credentials only when that channel is enabled:

• Telegram: bot token from BotFather, configured under gateway.telegram or a Telegram account entry.
• Feishu: app id/app secret. The default long-connect path uses the Metis-owned vendor SDK-backed Node sidecar, so install its local Node dependencies before enabling gateway.feishu.receiveMode = "long_connect".
• QQ: app id/app secret or the official gateway credentials required by the selected QQ mode.
• Plugin IM adapters: plugin runtime files plus the Python dependencies and credentials for that adapter.

Interactive CLI:

cjpm run --name metis
cjpm run --skip-build --name metis --run-args "chat"

Gateway runtime:

cjpm run --skip-build --name metis --run-args "gateway run"
cjpm run --skip-build --name metis --run-args "gateway serve"

Other entry points:

cjpm run --skip-build --name metis --run-args "dashboard"
cjpm run --skip-build --name metis --run-args "gateway help"

Logs and runtime diagnostics:

cjpm run --skip-build --name metis --run-args "logs path"
cjpm run --skip-build --name metis --run-args "logs recent"
cjpm run --skip-build --name metis --run-args "logs current"
cjpm run --skip-build --name metis --run-args "logs tail --limit 100"

Use gateway run --verbose for temporary runtime detail while diagnosing channel startup, inbound, outbound, or model failures. See docs/user/logging.md for the logging workflow.

Run optional verification only for the features you installed:

npm --prefix ui run build
npm --prefix tools/pdf_extract run check
npm --prefix tools/feishu-sidecar install
cjpm run --skip-build --name metis --run-args "models pdf-status"
cjpm run --skip-build --name metis --run-args "gateway channels get feishu"

Use the CLI when you want a local conversational interface with memory, commands, skills, and project instructions.

cjpm run --name metis

Inside the shell, common commands include:

• /help
• /conversation list
• /conversation save <name>
• /conversation resume <name>
• /memory
• /skills list
• /mcp
• /cron

Use the gateway runtime when you want a long-lived operational surface for CLI chat, APIs, managed sessions, channels, cron jobs, and delivery workflows.

metis gateway status
metis gateway health
metis gateway discover

Skills are packaged as directories containing SKILL.md and can be discovered from bundled, user, and workspace locations.

Examples:

/skills list
/skills info weather
/skills search weather
/weather Shanghai

Metis can manage MCP servers and expose its unified runtime through an MCP bridge.

metis mcp list
metis mcp serve --url ws://127.0.0.1:18788/ws

Metis supports managed agent sessions, bindings, and operational inspection through the gateway path.

metis agents list
metis sessions list
metis subagents list

AgentTeam can be managed today with agent CLI commands plus Gateway RPC team calls:

metis agents add --agent content-writer --name "Content Writer" --model openai:gpt-4o-mini
metis gateway call agents.teams.create '{"id":"content","displayName":"Content Team","template":"pm-writer-reviewer"}'
metis agents bind --agent content-writer --bind telegram:bot-a

See docs/user/agent-team.md for Gateway startup, team RPC usage, per-agent files/models, IM account binding, and current limitations.

Background subagents can be started from CLI or IM sessions without blocking the current conversation:

/subagents spawn explorer "analyze the gateway runtime and notify this session when done"

See docs/user/subagents.md for CLI, Telegram, natural-language, custom agent, policy, and control-ui usage.

The dashboard chat input supports the same slash menu shown by /help and /commands. Local Control UI commands return readable chat summaries and do not print raw JSON by default.

Common Control UI commands:

/help
/commands
/stop
/kill <id|all>
/steer [id] <message>
/redirect [id] <message>

/stop aborts only the current Control UI chat turn. /kill targets matching sub-agent sessions in the current Control UI session subtree. /steer soft-injects guidance into an active run without restarting it; use /redirect when the run should be aborted and restarted with a new message.

Cron jobs let you run agent work on recurring schedules and optionally route successful results back into channels or session targets.

metis gateway cron list
metis gateway cron run <job-id>

Metis stores user-facing runtime configuration under ~/.metis/.

Important files and directories:

• ~/.metis/metis.json for model, provider, gateway, tool, and MCP configuration
• ~/.metis/skills/ for user-managed skills
• ~/.metis/agents/ for custom subagents
• ~/.metis/conversation-history/ for saved conversations
• project AGENTS.md for workspace-specific instructions

The repository is organized around a few major surfaces:

• src/app/ for CLI interaction and command handling
• src/gateway/ for the unified runtime, channels, toolsets, transport, dashboard, and control UI
• src/core/ for conversations, memory, policies, and shared runtime behavior
• src/cron/ for recurring job scheduling and delivery
• src/mcp/ for MCP bridge and server support
• src/lsp/ for richer code-assistance infrastructure
• docs/ for runtime, parity, control, skills, and integration documentation
• skills/ for bundled skills
• tools/ for channel plugin tooling and supporting integrations

Metis ships with built-in channel support and also supports plugin-style integrations for external IM systems. The gateway/plugin model is designed so channels can feed normalized inbound events into the runtime and reuse the same agent, session, and delivery infrastructure.

That makes Metis suitable for:

• terminal-first agent workflows
• workspace-aware coding assistants
• private personal assistants with persistent context
• channel-connected bots for teams or personal messaging
• scheduled and semi-autonomous agent tasks

Useful project documents:

• README.md for the current project intro and command overview
• docs/user/telegram.md for Telegram channel configuration, media usage, and troubleshooting
• docs/user/pdf-tool.md for PDF reading, model configuration, fallback dependency installation, and Telegram PDF usage
• docs/user/subagents.md for background subagent usage and control-ui operations
• docs/user/skills-guide.md for skills discovery, commands, and installation
• docs/user/gateway-im-plugins.md for IM plugin integration
• docs/mcp.md for MCP-related configuration

Metis is a source-first Cangjie project. In practice, the most important setup steps are making MAGIC_PATH valid, configuring provider credentials in ~/.metis/metis.json, and deciding whether you are operating in interactive CLI mode, explicit local mode, or Gateway service mode.

If you are evaluating the codebase, start with:

1. cjpm.toml
2. src/program_runner.cj
3. src/app/
4. src/gateway/

This is a personal project based on magic-cli and CangjieMagic.

• https://gitcode.com/Cangjie-TPC/CangjieMagic
• https://gitcode.com/cangjie-sig/magic-cli