FuXi

English | 简体中文

An AI coding agent that lives in your terminal. Codename YiHuaKaiTian — "one stroke opens the heavens."

FuXi is a fast, self-contained AI developer terminal — a coding agent you drive from a rich TUI. It reads your codebase, edits files, runs commands, drives tools, and routes every request across multiple LLM providers with cost-aware routing and automatic failover. Written in Go, it ships as a single static binary with no runtime dependencies.

Homepage: https://www.fuxicode.com

• Multi-LLM routing — one agent, many providers. First-class support for:
  • Anthropic (native Messages API) and Anthropic on AWS Bedrock / Google Vertex
  • OpenAI-compatible endpoints (OpenAI, Azure OpenAI, and any OpenAI-style API)
  • Google Gemini
  • Popular open/China-hosted models via OpenAI-compatible endpoints — **GLM **, DeepSeek, Qwen, Hunyuan, Doubao, Ernie, Grok (xAI), and more
• Intelligence layer — cost-aware routing, automatic failover to a healthy provider, optional racing of primary vs. fallback, and role-based model tiers (fast / primary / reasoning) resolved from your config.
• A deep tool suite — file read/edit/write, shell (bash / PowerShell) with a safety classifier, web fetch, code search, LSP-backed diagnostics, Jupyter notebooks, computer/browser use via MCP, background tasks, and parallel sub-agents.
• MCP client — connect any Model Context Protocol server (stdio, HTTP, or WebSocket) and its tools become available to the agent.
• Extensible — hooks, skills, plugins, and user-defined slash commands.
• Durable sessions — persistent transcripts, checkpoints/resume, an idle "dreaming" memory, and automatic context compaction for long conversations.
• Bring your own key, or log in — use a provider API key, or sign in with FuXi OAuth. Keys are never required for the FuXi-managed path.
• Self-updating — a background version check and a one-command fuxi update keep your install current, with checksum verification before it ever replaces the running binary.

curl -fsSL https://releases.fuxicode.com/bootstrap.sh | bash

irm https://releases.fuxicode.com/bootstrap.ps1 | iex

curl -fsSL https://releases.fuxicode.com/install.cmd -o "%TEMP%\fuxi-install.cmd" && "%TEMP%\fuxi-install.cmd"

All three install to ~/.local/bin (%USERPROFILE%\.local\bin on Windows) and add it to your user PATH if it isn't there already. Running the same command again later upgrades an existing install in place — it's the same command for install and upgrade.

By default they install the latest version; pin a specific one with an argument, e.g. ./bootstrap.sh 2.202.194 or ./bootstrap.ps1 2.202.194.

Requires Go 1.26+:

git clone <this-repo>
cd fuxi
go build -o fuxi ./cmd/fuxi

fuxi --version
fuxi doctor      # environment sanity checks (config, API key, git, ripgrep, ...)

# macOS / Linux
rm -f "$HOME/.local/bin/fuxi"
rm -rf "$HOME/.fuxi"   # optional: also drop config/state

# Windows (PowerShell)
Remove-Item -Force "$env:USERPROFILE\.local\bin\fuxi.exe"
Remove-Item -Recurse -Force "$env:USERPROFILE\.fuxi"   # optional

Launch the TUI:

fuxi

On first run FuXi creates its config under ~/.fuxi/. You need a model to talk to, via one of two paths:

1. Sign in — fuxi login opens a browser to authenticate with your FuXi account, which provisions FuXi-managed models automatically. No API key needed.

2. Bring your own key — set a provider API key via environment variable, or write ~/.fuxi/config.yaml directly (fuxi init generates a starter template, auto-detecting a provider from whatever env vars are already set):

   provider: openapi
   base_url: https://your-endpoint/v1
   api_key: <your-key>       # or export FUXI_API_KEY instead
   model: glm-4.6

   Managing several providers/models instead of one? Use the layered schema — a providers: catalog plus a model: selection layer:

   providers:
     custom:
       type: openapi
       base_url: https://your-endpoint/v1
       api_key: <your-key>
       models:
         - id: deepseek-v4-pro-260425
           model_canonical_name: deepseek-v4-pro   # optional: for capability lookup
   model:
     active: { provider: custom, id: deepseek-v4-pro-260425 }

   See config.full.example.yaml for the full layered schema (multiple providers, per-model capability overrides, routing roles).

   Or run fuxi wizard for an interactive setup flow (pick a provider, enter the base URL/key, choose a model, test the connection).

Once a model is configured, pick it any time with /model, and manage the rest of your settings with /config — everything (permissions, hooks, skills, plugins) is driven from inside the TUI via slash commands.

The most commonly used flags when launching fuxi:

Run fuxi --help for the complete list (there are many more — sampling controls, tool restrictions, system-prompt overrides, hook triggers, and swarm/agent flags).

Type / and press Enter (or Tab-autocomplete) to browse all commands. The essentials:

Keyboard: / then Enter opens the command browser · Tab autocompletes a slash command · Ctrl+R searches prompt history · terminal paste / bracketed paste is supported for large pastes.

FuXi checks for new versions in the background and prints a one-line notice when one is available. Update in place with:

fuxi update            # latest
fuxi update 2.203.0    # a specific version

fuxi update downloads the target build, verifies its SHA-256 against the published manifest, and atomically replaces the running binary — it never leaves you with a partially-installed version. Suppress the background check with --no-update-notifier or NO_UPDATE_NOTIFIER=1.

• Config directory: ~/.fuxi/ (override with FUXI_CONFIG_DIR).
• Config file: ~/.fuxi/config.yaml — provider, model, thinking/effort, intelligence routing, redaction, and per-endpoint capability overrides. Changes hot-reload while FuXi is running. See config.full.example.yaml in this repo for every available field with inline documentation.
• Precedence: environment variables > config.yaml > built-in defaults.
• Project settings: a checked-in .claude/settings.json (permissions, hooks) is honored per-project.
• Plugins: first-party marketplace at fuxicode.com/plugins.

Key environment variables:

Run fuxi --help for the full environment-variable reference, including bridge/ remote-control, sandbox limits, and MCP resource caps.

FuXi is a single Go module. The entry point is cmd/fuxi; the bulk of the system lives under internal/ — the agent engine, TUI, tools, providers, MCP, session and memory services, the intelligence router, and the permission system.

Proprietary. Copyright © 2026 FUXI (Shanghai YiTai Technology Co., Ltd.). All rights reserved.