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.

fuxi --help also lists system-prompt overrides, tool restrictions, sampling controls, and swarm/agent flags.

Subcommands

In-TUI slash commands

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

Keyboard & input: / then Enter opens the command browser · Tab autocompletes a slash command · Ctrl+R searches prompt history · Ctrl+V or terminal paste pastes directly into the input · bracketed paste handles large pastes. The full shortcut reference is in docs/keybindings.md.

Updating

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 0.1.2      # 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.

Configuration

• Config directory: ~/.fuxi/ (override with FUXI_CONFIG_DIR).
• Config file: ~/.fuxi/config.yaml — provider, model, thinking/effort, routing preferences, and per-endpoint overrides. Changes hot-reload while FuXi is running. fuxi init generates a starter template, and /config manages settings from inside the TUI.
• Precedence: environment variables > config.yaml > built-in defaults.
• Project settings: a checked-in project settings file (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 sandbox limits and MCP resource caps.

Project layout

This repository hosts FuXi's documentation, release installers, and the issue tracker. The product source is proprietary and is not published here (see License).

• README.md / README.zh-CN.md — the main documentation (English / 简体中文)
• docs/ — demo GIF, comparison graphics, usage guide, keyboard reference, FAQ
• CHANGELOG.md — release history
• CONTRIBUTING.md, CODE_OF_CONDUCT.md, SECURITY.md, SUPPORT.md — community and support guides
• security-privacy/ — the Security & Privacy Program: governance charter, policies, standards, procedures, global compliance matrix, and trust center

License

Proprietary. Copyright © 2026 FUXI. All rights reserved.