FuXi

English | 简体中文

An AI coding agent that lives in your terminal.

FuXi is a fast, self-contained terminal AI coding agent — read code, edit files, run commands, and drive tools from a rich TUI, with cost-aware routing across LLM providers and automatic failover. Built in Go, it ships as one static binary with no runtime dependencies. Think of it as a provider-agnostic alternative to Claude Code: bring any OpenAI-compatible model and get an agentic Think → Act → Verify loop on top of it.

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

What FuXi does

Its agentic Think → Act → Verify loop and intelligent routing let any OpenAPI-compatible model perform above its raw benchmark — verified against another coding agent on a reproducible task set (see benchmark).

Contents

• Highlights
• How FuXi compares
• Evaluation & benchmarks
• Install
• Getting started
• Usage guide
• Keyboard shortcuts
• FAQ
• Security & privacy
• 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.

• 50+ built-in tools — file read/write/edit, shell (bash / PowerShell), ripgrep search, web fetch, LSP diagnostics, Jupyter, browser use, background tasks, and parallel sub-agents — all in one binary.
• Safety guardrails — shell commands pass an AST safety classifier before execution; fine-grained permissions and audit logging keep autonomous work under your control.
• Durable sessions & memory — transcripts persist to disk; checkpoints let you resume, roll back, or fork; idle "dreaming" consolidates memory across sessions; long conversations auto-compact to save tokens.
• Bring your own key, or log in — any provider API key (OpenAPI-compatible, Gemini, Bedrock/Vertex), or sign in with FuXi OAuth.
• Extensible — MCP client, hooks, skills, plugins, and 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 one-command fuxi update, with checksum verification before it 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.

Measured head-to-head

Both systems were driven through their own native clients, on identical baselines and the same objective scorer (pytest + coverage), across 15 micro dimensions and 4 large-project dimensions. Full methodology, raw results, environment versions, exact commands, and known limitations are in benchmark/REPORT.md so you can verify or re-run it.

An honest caveat: this is a small, self-run task set — not a third-party benchmark — and it measures the agent loop, not raw model scores. Treat it as a data point, not a headline.

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

For the complete, step-by-step guide — from installation to advanced features — see docs/usage.md. This section is a quick reference.

Command-line flags

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