Agents > Xedant Agent > Docs > Backends

Backends

Xedant Agent has the concept of a backend — the “engine”, the program that actually executes your tasks: reads files, edits code, runs commands. The application is not tied to one engine: it wraps any such agent and turns it into a full web interface with chat, files, version comparison (diff), builds, sessions, and analytics. Ten built-in backends are available out of the box — Claude Code (the default), Codex, OpenCode, Pi, Oh My Pi, Reasonix, DeepSeek Harness, Kimi Code, MiniAgent, and Command Code — and hooking up any new one takes about a day on request. MiniAgent is the only backend without an external program: it is built directly into Xedant Agent, so there is nothing to install.

All backends are built the same way (a single internal IAgentBackend interface), so they all look the same to you: the same chat interface, the same skills, hooks, builds, and statistics. Only the “engine” under the hood changes — which executable actually runs for each message. Skills still load automatically: the requirement is delivered to every backend over its own out-of-band channel — a system prompt line, a launch flag, an environment variable, or a file bound to the chat (details on the Skills page).

How it works

The backend is chosen by the AGENT_BACKEND variable, which is set in the model’s configuration (see Models). The choice follows the same rules as the other variables:

  1. The model selected for the chat is taken;
  2. If none is set, the selectedModel setting is used;
  3. If that is missing too, the default model is taken;
  4. AGENT_BACKEND is read from the resulting set of variables. If it is missing, claude-code is used.

Allowed values: claude-code (the default), codex, opencode, pi, oh-my-pi, reasonix, deepseek-harness, kimi-code, mini, command-code. So you can switch the engine per chat — just change the chat’s model.

Automatic installation. If the required executable is not on the machine, Xedant Agent installs it itself on the first message (through the npm package manager) and streams the progress live right into the chat. You usually do not need to install anything manually. The exception is MiniAgent: it needs no external program at all, because it is built into Xedant Agent itself.

Built-in backends

  • Claude Code — package @anthropic-ai/claude-code. The base backend, and the default. Full support: internal proxy, subagents, skills, model switching.
  • Codex — package @openai/codex. GPT-5 models from OpenAI. Sign in with a ChatGPT subscription (Go/Plus/Pro, flat-rate) or use a prepaid API key. Tested as excellent — works fully.
  • OpenCode — package opencode-ai. The universal engine: connect any provider you like (Anthropic, OpenAI, Gemini, a local model).
  • Pi — package @earendil-works/pi-coding-agent. A minimal, extensible agent from pi.dev. Works with any provider on your own key.
  • Oh My Pi — package @oh-my-pi/pi-coding-agent. An extended Pi from omp.sh: the same capabilities plus ready presets and tools out of the box.
  • Reasonix — package reasonix. An agent built for DeepSeek (reasonix.io): DeepSeek-V4 Flash/Pro models, a huge context — 1 million tokens. DeepSeek key, no subscription. Tested as excellent — works fully.
  • DeepSeek Harness — DeepSeek’s own open agent (deepseek-harness). An “everything is a plugin” architecture: the core loop, tools, and the DeepSeek adapter all plug in. DeepSeek-V4 Flash/Pro models, 1 million tokens of context. DeepSeek key, no subscription.
  • Kimi Code — package @moonshot-ai/kimi-code. An agent from Moonshot AI (kimi.com). Works with Kimi models or any compatible provider on your own key.

How to connect a backend

Connecting one comes down to creating a model with the right AGENT_BACKEND variable and the target engine’s credentials:

  1. Open Settings → Models and press “Create”;
  2. Pick a ready provider template — Codex, Reasonix, OpenCode, Pi, Oh My Pi, DeepSeek Harness, or Kimi Code; for MiniAgent — a provider template that supports this backend (Anthropic, DeepSeek, z.ai, and others), and for Command Code — a Custom type model (it has no ready template). The templates already carry AGENT_BACKEND and the variables you need;
  3. Fill in the API key (the secret access key) or sign in (for Codex — the /login button with a ChatGPT subscription);
  4. Select that model for a chat — the executable installs automatically on the first message.

Or create a Custom model and set the variables manually — this gives you full control. Example for Codex:

AGENT_BACKEND=codex
CODEX_API_KEY=$CODEX_API_KEY      # or sign in with ChatGPT instead of a key
MODEL=gpt-5.6-sol

Claude Code (the default)

The base backend everything else runs on. Package @anthropic-ai/claude-code (2.1.217 by default), executable claude. Supports the internal proxy server for traffic logging and cost accounting, subagents, skills, and switching between Opus/Sonnet/Haiku models on the fly.

Two ways to sign in, controlled by the ANTHROPIC_AUTH variable:

  • Claude subscription (ANTHROPIC_AUTH=claude) — runs on your Claude plan (Pro/Max) with no per-token billing. No key needed: when a chat uses such a model, a “Sign in with Claude” prompt appears at the bottom of the chat with the explanation “Use your Claude plan (Pro/Max) with Claude Code”. Click it, open the “Open Claude sign-in” link, sign in to your Claude account, and paste the code you receive into the field — after a successful login you will see “Signed in with Claude”, and chats start running on the subscription;
  • Access key — ANTHROPIC_API_KEY (a direct Anthropic key) or ANTHROPIC_AUTH_TOKEN (a token for compatible proxies, z.ai for example); the provider address is set with ANTHROPIC_BASE_URL.

Codex

Codex CLI from OpenAI — GPT-5 models. Package @openai/codex (0.146.0 by default), executable codex, launched as codex exec --json: one process per message, events arrive as a stream in the NDJSON text format (one record per line), and the run ends when the process exits. Sessions are saved and resumed through resume.

Two ways to sign in, controlled by the CODEX_AUTH variable (auto by default):

  • ChatGPT subscription (CODEX_AUTH=chatgpt) — flat-rate use on the Go/Plus/Pro plan. You sign in with the /login command: the auth.openai.com link opens, you enter a code, and the account is stored in ~/.codex/auth.json. Subscription usage is tracked by a built-in service.
  • API key (CODEX_AUTH=apikey, or when there is no login) — prepaid credits. The variables OPENAI_API_KEY/CODEX_API_KEY and optionally OPENAI_BASE_URL for a proxy.

In auto mode (the default) Xedant Agent picks by itself: if a ChatGPT login exists, the subscription is used; otherwise — the API key.

Available models: gpt-5.6-sol (flagship), gpt-5.6-terra (balanced), gpt-5.6-luna (fast and affordable). Set with the MODEL variable.

Codex is tested as excellent and works fully — chat, tools, sessions, analytics, and subscription quota tracking.

OpenCode

The universal engine from opencode.ai. Package opencode-ai (current version), executable opencode, launched as opencode run --format json. An alternative one-script install: curl -fsSL https://opencode.ai/install | bash.

Sign-in — your own provider key (no subscriptions):

  • ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY — the key of the provider you need;
  • LOCAL_ENDPOINT — for a local model;
  • any variable with the OPENCODE_ prefix.

The model is set in the “provider/model” format, for example MODEL=anthropic/claude-sonnet-4-20250514.

Pi

A minimal, extensible agent from pi.dev. Package @earendil-works/pi-coding-agent (current version), executable pi, launched in pi --mode rpc mode — Xedant Agent talks to it over an RPC protocol (commands like set_model), sessions are saved in the JSONL text format (one record per line) and resumed after a restart.

Sign-in — your own provider key, as with OpenCode:

  • ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, LOCAL_ENDPOINT;
  • any variable with the PI_ prefix.

The model — in the “provider/model:thinking” format, for example MODEL=anthropic/claude-sonnet-4-20250514:medium (the :thinking suffix sets the reasoning level).

MiniAgent

MiniAgent is the built-in backend: not an external program but a C# library compiled right into Xedant Agent (a minimal Pi-style coding agent fully rewritten in C#). No external process is launched and no npm package is installed — the backend is always “at hand” for the server. Selected with AGENT_BACKEND=mini.

Its capabilities are like Pi’s: the tools read, write, edit, bash, grep, find, ls plus glob and skill loading with load_skill, JSONL sessions that resume after a restart, model and reasoning-level switching on the fly, automatic context compaction, retries on transient failures, and cost accounting. Tools run sequentially, as in Claude Code. On top of that, MiniAgent supports named settings profiles (the miniagent.yml file, overridden by the MINI_PROFILE_* variables) and the parallel_bash tool for running commands in parallel — see the MiniAgent page for details.

The model is set in the “provider/model:thinking” format, for example MODEL=anthropic/claude-sonnet-5:medium (the :thinking suffix sets the reasoning level: off, minimal, low, medium, high). The ready provider templates — Anthropic, DeepSeek, z.ai, BigModel, OpenRouter, xAI, MiniMax, Moonshot, OpenAI, OpenCode Go/Zen — already carry the MiniAgent backend and its parameters: MINI_BASE_URL (the address), MINI_API (the protocol format — anthropic-messages or openai-completions), MINI_AUTH (api-key or bearer), and MINI_API_KEY (the key). Any model the templates do not know is assembled automatically from these parameters, or — when a ~/.mini/models.json file exists — from it (a format compatible with Pi). If no model is set at all, deepseek/deepseek-v4-flash is used by default.

MiniAgent’s data lives in the ~/.mini folder (overridable with the MINI_AGENT_DIR variable): models.json — the model configuration, agent-sessions — sessions (JSONL, resumed after a restart), skills — extra skills and the global CLAUDE.md.

Out of the box, MiniAgent does by itself what other backends need configured: it reads the project’s CLAUDE.md/AGENTS.md (CLAUDE.md takes priority), finds the .claude/skills skills on its own, and documents the interactive forms and buttons (agent.form/agent.button) right in the system prompt. Passing images into the chat is not wired up yet — images are ignored on send with a warning in the log.

Full overview of MiniAgent’s capabilities and setup →

Reasonix

A coding agent built for DeepSeek (reasonix.io). Package reasonix (current version), executable reasonix, launched as reasonix run --output-format stream-json --auto: one process per message, events arrive as a stream (NDJSON), and the run ends when the process exits. Sessions are saved as JSONL and resumed with --resume.

Sign-in — a DeepSeek key (no subscription, prepaid credits):

  • DEEPSEEK_API_KEY — the key for api.deepseek.com;
  • for any OpenAI-format provider (OpenRouter and the like) — REASONIX_BASE_URL, REASONIX_API_KEY, and the model (REASONIX_MODEL or MODEL).

Reasonix reads provider keys only from its own config (<REASONIX_HOME>/.env), not from environment variables — but Xedant Agent writes the permitted keys there itself before launch, so you never configure anything by hand.

The DeepSeek models — Flash (fast, the default) and Pro. The context is 1 million tokens. Set with the MODEL variable in the “provider/model” format (for example deepseek/deepseek-v4-pro); the ready Reasonix environment templates already carry the right value.

Reasonix is tested as excellent and works fully — chat, tools, reasoning, sessions, and analytics.

Oh My Pi

An extended version of Pi from omp.sh. Package @oh-my-pi/pi-coding-agent, executable omp, launched in omp --mode rpc mode — the same RPC protocol as Pi, so the capabilities are identical: sessions, model switching, tools. The differences are the set of ready presets and tools “out of the box”, plus it stores sessions in its own folder ~/.omp/agent/sessions.

Sign-in — your own provider key, as with Pi:

  • ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, LOCAL_ENDPOINT;
  • any variable with the OMP_ prefix (for example OMP_PROVIDER — the default provider when the model does not name one).

The default model is anthropic/claude-sonnet-5. The reasoning level is set separately after the process starts, so the :thinking suffix in the model name is not needed.

DeepSeek Harness

DeepSeek’s own open agent (github.com/deepseek-ai/deepseek-harness, dsh for short). Its signature trait is the “everything is a plugin” architecture: the core loop, tools, and the DeepSeek adapter all plug in. Xedant Agent runs it as one persistent process per chat and talks to it over the JSON-RPC protocol (function calls in text form): tokens, tool calls, task lists, and cost arrive in the chat in real time.

First launch. The executable is not installed through npm: on first use Xedant Agent provisions a managed runtime folder itself (~/.dsh/agent-runtime under the server user’s home), installs a pinned set of packages, and generates the config. Node.js 22.19+ or 24+ is required — the installer checks this up front.

Sign-in — a DeepSeek key (no subscription, prepaid credits):

  • DEEPSEEK_API_KEY — the key for api.deepseek.com;
  • DEEPSEEK_BASE_URL — the address of another OpenAI-format provider (by default — DeepSeek directly).

The models — deepseek-v4-flash (fast, the default) and deepseek-v4-pro (deeper) — are set with the DSH_MODEL variable. The context is 1 million tokens. Switching the model restarts the agent process.

DeepSeek Harness subagents open as separate child chats (as with Claude Code), task lists render as checklists, and cost is computed from DeepSeek’s prices with caching accounted for. After a pause or restart, the agent receives a short recap of the previous dialog — the files on disk remain the main result of the work.

DeepSeek Harness is in active development (a preview version). Package versions are pinned, so updating is a deliberate act — through the DSH_RUNTIME_VERSION variable.

Kimi Code

A coding agent from Moonshot AI (kimi.com). Package @moonshot-ai/kimi-code, executable kimi, launched as kimi -p "<prompt>" --output-format stream-json: one process per message, events arrive as a stream (NDJSON), and the run ends when the process exits. Sessions are saved and resumed through --session. Node.js 22.19+ is required.

Sign-in — through the model channel variables (this is the only way Kimi Code accepts a key from environment variables — it ignores a plain KIMI_API_KEY):

  • KIMI_MODEL_NAME — the model name (this variable’s presence turns the channel on);
  • KIMI_MODEL_API_KEY — the provider key;
  • KIMI_MODEL_BASE_URL — the provider address (by default — the Kimi provider);
  • KIMI_MODEL_PROVIDER_TYPE — the protocol format: kimi, anthropic, or openai;
  • KIMI_MODEL_MAX_CONTEXT_SIZE — the context size in tokens (262144 by default).

Instead of a key, you can use an existing OAuth login (browser authorization) stored in ~/.kimi-code. The ready provider templates (Anthropic, DeepSeek, Moonshot, and so on) already carry the right values — nothing to configure by hand.

Command Code

A coding agent from Langbase (commandcode.ai) — a cross-platform terminal agent with closed source. Package command-code, executable cmd (on Windows — cmdc), launched as cmd -p "prompt" --output-format json: one process per message, events arrive as a stream (NDJSON), and the run ends on the result line. Node.js 22+ is required.

Writing, editing files, and shell commands in headless mode are forbidden by default — Xedant Agent launches Command Code with the --yolo flag, which enables them. Sessions are not saved to disk: the dialog context travels inside every new message.

Sign-in — only through a Command account (a subscription or a prepaid API key; Anthropic/OpenAI/DeepSeek keys are not accepted):

  • cmd login — sign-in through the browser (OAuth); the account is stored in ~/.commandcode;
  • COMMAND_CODE_API_KEY — the Command Code API key; set in the model configuration and takes priority over the login.

The model is set with the MODEL variable (a Command account gives you 30+ models). If no model is set, cmd uses its own default; an unknown model name is an error, so check the spelling. Tokens and cost arrive in each reply’s result line and land in the chat and analytics.

Command Code looks for its own skills in the .commandcode/skills and .agents/skills folders, so Xedant Agent adds a pointer to the .claude/skills skills to the prompt itself — “call the skill” works as usual.

Variable reference

  • AGENT_BACKEND — backend selection: claude-code (the default), codex, opencode, pi, oh-my-pi, reasonix, deepseek-harness, kimi-code, mini, command-code
  • CLAUDE_PATH / CODEX_PATH / OPENCODE_PATH / PI_PATH / OMP_PATH / REASONIX_PATH / KIMI_CODE_PATH / COMMAND_CODE_PATH — the path to a specific executable (overrides auto-discovery)
  • CLAUDE_CODE_VERSION / CODEX_VERSION / OPENCODE_VERSION / PI_VERSION / OMP_VERSION / REASONIX_VERSION / KIMI_CODE_VERSION / COMMAND_CODE_VERSION — pin a version for auto-installation
  • CODEX_AUTH — how Codex signs in: auto (the default), chatgpt, apikey
  • OPENAI_API_KEY / CODEX_API_KEY — a prepaid OpenAI key for Codex (+ OPENAI_BASE_URL for a proxy)
  • DEEPSEEK_API_KEY — the DeepSeek key for Reasonix and DeepSeek Harness; or REASONIX_BASE_URL + REASONIX_API_KEY for an OpenAI-format provider (OpenRouter and the like)
  • DSH_MODEL — the DeepSeek Harness model: deepseek-v4-flash (the default) or deepseek-v4-pro
  • DSH_RUNTIME_VERSION / DSH_RUNTIME_DIR / DSH_AGENT_PATH — control of the dsh runtime (package version, runtime folder, an explicit executable path)
  • DSH_PERMISSION_MODE — the dsh access mode: danger-full-access (the default) or workspace-write (stricter, with permission requests)
  • KIMI_MODEL_NAME / KIMI_MODEL_API_KEY / KIMI_MODEL_BASE_URL / KIMI_MODEL_PROVIDER_TYPE / KIMI_MODEL_MAX_CONTEXT_SIZE — the Kimi Code model channel (see the section above)
  • COMMAND_CODE_API_KEY — the Command Code API key (takes priority over the cmd login sign-in)
  • MINI_PROVIDER — MiniAgent’s default provider when the model has no provider/ prefix
  • MINI_BASE_URL / MINI_API / MINI_AUTH / MINI_API_KEY — MiniAgent connection parameters for automatic model assembly: the provider address, the protocol format (anthropic-messages or openai-completions), the authorization type (api-key or bearer), and the access key
  • MINI_AGENT_DIR — MiniAgent’s data folder (~/.mini by default): sessions, models.json, skills, the global CLAUDE.md
  • MODEL — the model in the backend’s own format (a name for Codex and Command Code, provider/model for OpenCode, Pi, Reasonix, and MiniAgent)

Installation and versions

By default the executables install automatically through npm on first use. If you need to install manually:

npm install -g @anthropic-ai/claude-code   # Claude Code
npm install -g @openai/codex               # Codex
npm install -g reasonix                    # Reasonix (or: brew install esengine/reasonix/reasonix)
npm install -g opencode-ai                 # OpenCode (or: curl -fsSL https://opencode.ai/install | bash)
npm install -g @earendil-works/pi-coding-agent  # Pi
curl -fsSL https://omp.sh/install | sh            # Oh My Pi (the npm package alone does not run)
npm install -g @moonshot-ai/kimi-code            # Kimi Code
npm install -g command-code                    # Command Code (executable cmd, on Windows — cmdc; Node.js 22+ required)
# DeepSeek Harness — no manual install: the runtime is provisioned automatically (Node.js 22.19+ or 24+ required)
# MiniAgent — nothing to install: it is built into Xedant Agent

You can pin the version with an environment variable (for example CODEX_VERSION=0.146.0) or point to the exact executable path with *_PATH — then auto-installation is not needed at all.

MiniAgent never needs installing: it is built into Xedant Agent itself, so it has no npm package, no version variable, and no separate executable.

Status and support

  • Claude Code — the default backend, works perfectly: full functionality without limits.
  • Codex is tested as excellent — stable, fully functional: chat, tools, sessions, analytics, ChatGPT quota tracking.
  • Reasonix is tested as excellent — stable, fully functional: chat, tools, DeepSeek reasoning, sessions, and analytics.
  • Kimi Code is tested as excellent — stable work: chat, tools, sessions, analytics from the traffic log.
  • OpenCode, Pi, and Oh My Pi are implemented and connect, but as newer backends they may have small rough edges. Any bugs in them are fixable within a couple of hours on request.
  • Command Code — implemented and connects; as a new backend it may have small rough edges, and full testing with a live key is still ahead.
  • DeepSeek Harness — a preview version from DeepSeek: in active development, versions pinned. Works: chat, tools, subagents, task lists, cost.
  • MiniAgent — the built-in backend: works immediately, with no installation; chat, tools, sessions, cost, and analytics. It has passed a full test cycle — model switching, stop and resume, context compaction.
  • A new backend on request — need to hook up another agent (Gemini CLI, Cursor, Aider, and the like)? The IAgentBackend architecture allows it: connecting any new backend takes about a day.

← Back: Models

Next: MiniAgent →