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: read code, edit files, run commands, and drive tools from a rich TUI, with cost-aware routing across many LLM providers and automatic failover. One static binary, no runtime dependencies.

Terminal-first · Provider-agnostic · Bring your own key · MCP client · Self-updating

Homepage: https://www.fuxicode.com

curl -fsSL https://releases.fuxicode.com/bootstrap.sh | bash   # install
fuxi                                                        # start

Contents

• Highlights
• How FuXi compares
• Evaluation & benchmarks
• Install
• Getting started
• Usage guide
• Keyboard shortcuts
• FAQ
• Changelog
• Support
• Project layout
• License

Highlights

The model is the engine. FuXi is the vehicle. A model alone answers questions; FuXi turns it into a worker — reasoning, acting on your real codebase, verifying results, and doing it affordably and under your control.

• Think → Act → Verify loop — FuXi does not just answer. It works in a loop: reason about the task, act with tools (edit files, run commands, search code), inspect the result, and iterate until the work is done and verified — a failing test fixed, a suite green, a PR ready.
• Intelligent routing — every request is scored by complexity and routed to the right model tier: cheap models handle simple tasks, powerful models are reserved for hard ones. Automatic failover and optional primary-vs- fallback racing keep you working when a provider stumbles.
• 50+ built-in tools — file read/write/edit, shell (bash / PowerShell), ripgrep search, web fetch, LSP-backed diagnostics, Jupyter, browser use via MCP, background tasks, and parallel sub-agents — all in one binary.
• Safety guardrails — shell commands pass an AST safety classifier and a rule set before execution; fine-grained permissions, audit logging, and an explicit permission model keep autonomous work under your control.
• Durable sessions & memory — transcripts persist to disk; checkpoints let you resume, roll back, or fork; an idle "dreaming" pass consolidates memory across sessions; long conversations auto-compact to save tokens.
• Bring your own key, or log in — use any provider API key (OpenAI- compatible, Gemini, Bedrock/Vertex, or other OpenAI-compatible endpoints), or sign in with FuXi OAuth. Data stays under your control.
• Extensible — MCP client, hooks, skills, plugins, and user-defined slash commands, all hot-reloadable.
• Free forever — one static binary, no runtime dependencies, no license cost for individuals, teams, or enterprises.
• 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.

How FuXi compares

FuXi is a terminal-first AI coding agent designed to be provider-agnostic. Feature availability reflects each product's publicly documented positioning as of mid-2026; details evolve quickly, so treat it as an orientation.

Evaluation & benchmarks

FuXi is built to be measured honestly. It currently ships without a published score on third-party benchmarks (e.g. SWE-bench, Terminal-Bench, or the Aider polyglot benchmark). We prefer reproducible, self-verifiable evaluation over headline numbers — so here is how to evaluate FuXi yourself, on your own work.

A practical evaluation checklist

1. Install & self-check — after installing, run fuxi doctor to verify your environment (config, API key, git, ripgrep) and fuxi verify to confirm the provider connection. A clean bill here is the baseline.
2. Reproduce a real task — pick a failing test in one of your own projects and let FuXi fix it; then extend the module and re-run the suite (the demo above shows exactly this flow). Repeat across a handful of daily tasks: code review, commits, PRs, refactors.
3. Compare side by side — run the identical task, model, and context through another tool and compare: correctness, tool coverage, cost, and iteration time. Judging on the same ground keeps the comparison fair.

FuXi exposes everything needed for that comparison — /cost, /usage, /context, and /status inside the TUI — and ships its own environment self-check (fuxi doctor). Benchmarks that are published in the future will be linked from this section.

Install

macOS / Linux

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

Windows (PowerShell)

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

Windows (CMD)

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 0.1.2 or ./bootstrap.ps1 0.1.2.

Verify the install

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

Uninstall

# 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

Getting started

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: your-model
   

   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: your-model-id
   model:
     active: { provider: custom, id: your-model-id }
   

   The layered schema supports multiple providers and per-model settings.

   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.

Usage guide

Command-line flags

Common flags when launching fuxi, grouped by purpose. The complete reference is in fuxi --help.