Kcoder

KCoder

KCoder is an agentic AI coding platform built by KunlunMeta Artificial Intelligence Technology (Shanghai) Co., Ltd. It is an engineering-grade agent runtime rather than a wrapper that prints model output to the terminal: model providers, the agent loop, the tool system, permissions and sandboxing, structured long-term memory, Skills, spec-driven workflows, plugin hooks, MCP, sub-agents, session state, a terminal TUI, background daemons, Goal Pro long-objective verification, and desktop/Web/mobile access through KCoder Studio.

This repository is the public source snapshot of KCoder and the home of its installer releases.

What is inside:

• crates/ — the Rust workspace: cross-crate contracts (kcoder_types), configuration (kcoder_config), provider transports (kcoder_api), session state (kcoder_state), orchestration (kcoder_engine), tools (kcoder_tools), permissions (kcoder_permissions), hooks and plugins (kcoder_hooks, kcoder_plugins), MCP (kcoder_mcp), specs (kcoder_specs), workflows (kcoder_workflow), memory and skills (kcoder_memory, kcoder_skills), the TUI (kcoder_repl), the binary and app-server (kcoder_cli), and the app-server wire contract (kcoder_app_protocol). The [Repository Layout](#repository-layout) section lists every crate.
• apps/kcoder-studio/ — KCoder Studio: a Tauri desktop shell with a React renderer, speaking the same app-server JSON-RPC contract used by Web and mobile clients.
• scripts/ and tools/ — build, installer and verification helpers used by the release flow.

The single canonical entry point is kcoder: the installer, docs, scripts, and everyday usage all standardize on it. kcoder --help or -h is a read-only probe and does not initialize any user configuration.

Screenshots

Terminal TUI:

KCoder Studio (desktop app):

Current Positioning

KCoder aims to be more than a wrapper that simply prints model output to the terminal — it is an auditable, extensible, locally runnable engineering-grade agent runtime:

• Clear boundaries between providers, engine, tools, TUI, memory, permissions, specs, hooks, workflows, etc. through modular crate splits.
• Unified Tool trait managing built-in tools, MCP tools, and future plugin contributions.
• Permission modes, Landlock sandbox, hook events, audit logs, and tool output truncation reduce automation risk.
• Structured SQLite (+FTS5) memory, observer, privacy policy, and /memories status support long-term context.
• A spec-driven workflow turns engineering discipline, change planning, TDD, verification, and archival flows into tool-executable workflows.
• TUI queue, real-time rendering, tool status, background sub-agents, /goal objective progression, and /goal-pro strict verification support long tasks.
• app-server (JSON-RPC over stdio) and Gateway act as a machine-readable backend for desktop/Web/mobile clients, enabling KCoder Studio multi-platform access.

Quick Start

Windows users can install the packaged KCoder Studio (desktop app with the bundled CLI and browser resource) from Releases: download KCoder-Studio-Setup--win-x64.exe and verify it against the matching SHA256SUMS.txt published with every build. The rest of this section builds from source.

The local release installer builds kcoder from the current checkout without contacting GitHub Releases or cloud CI, nor invoking sudo, reading source .env, or importing any credentials. Prepare a Rust toolchain (Rust 1.95) first and enter the repo:

git clone https://github.com/KunlunMeta-dev/Kcoder.git
cd Kcoder
scripts/install/installers/cli-release.sh
export PATH="$HOME/.local/bin:$PATH"
kcoder --version

On Linux the build needs the Secret Service client library used by the OS credential store: sudo apt install libdbus-1-dev (or the equivalent for your distribution).

By default it executes cargo build --release --locked; if a local release binary already exists, use KCODER_RELEASE_BIN= to skip the build. The first run will create the missing ~/.config/kcoder/settings.json; existing files will not be overwritten. See the complete boundary between installer local builds and server deployments in scripts/install/README.md.

Windows PowerShell users run a local MSVC release build inside the checkout:

git clone https://github.com/KunlunMeta-dev/Kcoder.git
Set-Location Kcoder
.\scripts\install\installers\cli-release.ps1
$env:Path += ";$env:LOCALAPPDATA\Programs\KCoder\bin"
kcoder.exe --version

Uninstall by running scripts/install/installers/uninstall.ps1 (or uninstall.sh); user configuration, credentials, and history are preserved.

To install system-wide commands from source, use scripts/install/installers/cli-release-server.sh (release) and cli-dev-server.sh (debug). Both must run as root and only update /usr/local/bin system entries. The release entry uses the formal ~/.config/kcoder, and does not import dev configuration or repo credentials; the debug entry uses an isolated ~/.config/kcoder-dev and syncs dev configuration and provider credentials.

The Linux system release installer also prepares a pinned version of Google Chrome for Testing; the complete Studio package for Windows/Linux also ships this resource. For offline input, SHA-256 verification, and uncovered CLI package boundaries, see scripts/release/README.md (Chrome packaging notes). Browser dependency download failures will be flagged explicitly and do not affect CLI installation.

First-time configuration:

kcoder config init
kcoder auth login --provider kunlunmeta

# Launch TUI in any project directory.
cd /path/to/project
kcoder

You can also use kcoder auth import --env-file .env to import credentials for all configured Providers from dotenv at once. API keys are always written to credentials.json with permission 0600, not settings.json.

If you only need standalone release attachments, use scripts/release/package_release.sh / package_release.ps1 to generate CLI tar.gz or ZIP (including the lib/kcoder/rg bundled for the target platform); the CLI release installer does not download these cloud attachments by default. On Linux hosts, you can use scripts/release/package_windows_release.sh to cross-build a Windows GNU CLI ZIP.

KCoder Studio (desktop/Web/mobile) launch:

scripts/install/installers/studio-client.sh  # first-time user-level install of the kcoder-studio command
kcoder-studio --dev                            # start Electron directly, no systemd dependency

For a managed mode that survives terminal exit:

scripts/launch/kcoder-studio-web-dev.sh            # default systemd-managed dev profile
scripts/launch/kcoder-studio-web-release.sh        # default systemd-managed release profile
scripts/launch/kcoder-studio-web-dev.sh --direct   # optional: foreground Electron

The managed mode installs and starts four systemd units: Gateway 4173 only listens on loopback, Studio Web 4174 and Mobile Web 4175 default to listening on all local network interfaces on the corresponding ports, and the Expo bundler 14175 listens only on loopback. kcoder-studio --dev or --direct is launched by Electron which spawns a loopback Gateway; the Gateway manages a profile-matching kcoder app-server on demand and cleans up child processes on exit. Plain CLI installation only provides the terminal command and does not configure systemd. See the Studio Gateway security model and app-server protocol details in the [KCoder Studio](#kcoder-studio) section below.

After installation you can run directly in any project directory:

kcoder
kcoder "run the tests and fix failures"

First run

kcoder config path                      # where settings live
kcoder auth login --provider  # API keys go to credentials, never to settings
kcoder "summarize this repository"

Providers, endpoints, models and runtime knobs belong to settings.json; API keys belong to credentials.json and are written by kcoder auth. JSONC comments and trailing commas are supported, and settings.schema.jsonc in the same directory provides editor validation.

Configuration

KCoder uses layered configuration; later-loaded files override earlier-loaded scalars and arrays; nested objects are merged field by field, so the project layer can either change a single subfield or use an empty array to clear user-layer lists:

| File | Scope | Git | Suitable for | |------|------|-----|----------| | ~/.config/kcoder/settings.json | User | N/A | Models and personal preferences common to all projects | | /settings.json | Executable directory | Managed with the release package or deployment directory | Runtime configuration from release packages, portable deployments, or administrator | | .kcoder/settings.json | Project | Recommended to commit | Team-shared permissions, MCP, and project model settings | | .kcoder/settings.local.json | Project personal | Auto-ignored by .kcoder/.gitignore | Per-user override for the current project |

The full priority from low to high: embedded defaults (settting_inline.jsonc → schema) → user configuration → executable directory configuration → project configuration → project local configuration → explicit --settings-file overlay (repeatable, later has higher priority) → environment variables → CLI arguments. When launched from a project subdirectory, it walks upward to find the nearest .kcoder configuration; the program does not auto-scan the workspace .env, and .env under the user profile only supplements missing environment variables.

Each launch atomically replaces the bundled settings.schema.jsonc into the user configuration directory for editor validation and completion; the configuration metadata meta.config_version is currently 1; future versions will explicitly reject old files at load time. The only Provider bundled is kunlunmeta; when providers is declared in any explicit configuration file, only the union of names declared by these files is kept; removed configurations must not be re-added via defaults, imports, or bootstrap packages.

Common commands:

kcoder config path
kcoder config init --scope user
kcoder config list --sources
kcoder config get model --source
kcoder config set model MiniMax-M3
kcoder config set permission_mode auto --scope project
kcoder config unset permission_mode --scope project
kcoder config import --file team-settings.jsonc --scope project
kcoder config migrate
kcoder config validate

config set first parses the value as JSON (true/false/numbers/arrays/objects use valid JSON, others are treated as strings), and after each modification it reloads and validates the merged result; config set/unset triggers the ConfigChange lifecycle hook and rejects secret fields like *_api_key. Write scopes are only user, project, local; the program directory configuration belongs to the deployment environment and should not be modified via command.

Model services use the centralized providers configuration. Object keys are Provider IDs, and also determine the endpoint, authentication namespace, default model, and model capabilities. config migrate only fills missing fields, does not overwrite user values, and value-preserving migrates the legacy top-level provider/model/endpoint/token fields into the current Provider to prevent them from continuing to override new configuration under a new Provider:

{
  "active_provider": "kunlunmeta",
  "providers": {
    "kunlunmeta": {
      "api_format": "anthropic_messages",
      "endpoint": "http://127.0.0.1:8000",
      "default_model": "MiniMax-M3",
      "reasoning_effort": "high",
      "context_window_tokens": 1048576,
      "output_headroom_tokens": 100000,
      "max_output_tokens": 100000,
      "request_timeout_secs": 300,
      "no_proxy": true,
      "extra_body": {}
    }
  }
}

The kunlunmeta endpoint defaults to http://127.0.0.1:8000 (example environment, please override based on actual deployment), and the default model is MiniMax-M3; can be overridden by KUNLUNMETA_BASE_URL and KUNLUNMETA_BASE_MODEL respectively. api_format supports anthropic_messages, openai_responses, openai_chat_completions, and gemini_generate_content. API keys do not belong to Provider configuration and continue to be saved independently by auth to credentials.json. extra_body can configure provider extension request fields such as temperature, top_p, thinking budget, etc.; internal or local endpoints can set "no_proxy": true to ignore process HTTP proxies. Summary models can reference a full profile via summary_profile; MoA's reference/aggregator model slots can add "profile": "profile-name" to avoid inheriting the main model's protocol and endpoint. Other Providers like local, OpenAI-compatible, etc. must fully declare endpoint, protocol, default model, and model capabilities; Provider IDs are case-sensitive and must exactly match the auth login --provider and credentials.json root key.

KCODER_CONFIG_DIR (or the compatible KCODER_HOME) can override the user configuration directory, suitable for containers, tests, and multiple account isolation. Credential management:

kcoder auth login --provider kunlunmeta
kcoder auth import --env-file .env
kcoder auth status
kcoder auth logout --provider kunlunmeta

credentials.json uses an authentication map with Provider IDs as root keys:

{
  "kunlunmeta": { "type": "api", "key": "..." }
}

Environment variables still apply for CI or ad hoc runs, e.g. KUNLUNMETA_BASE_API_KEY, KCODER_PROVIDER, KCODER_MODEL, and KCODER_PERMISSION_MODE. --credential-env-file can supply a dotenv credential file for a single process. The final credential priority: explicit CLI credential argument > credentials.json > legacy compat-period settings credential fields > KunlunMeta environment variables.

Trust and Skill Preflight

When unattended tasks depend on project Skills, explicitly declare and only trust the target root before starting:

kcoder trust status --path /srv/project
kcoder trust add --path /srv/project
kcoder trust never --path /srv/project
kcoder trust revoke --path /srv/project
kcoder --cwd /srv/project --require-skill ci-triage --json "execute CI triage"

trust reads and writes FolderTrustStore (located in the configuration directory); --require-skill is repeatable and preflights before the first model request: when the Skill is not installed, the project is not trusted, the tool profile does not expose skill, or permissions deny, KCoder first returns a structured blocked (preflight_failed + termination_reason=required_skill_unavailable, resume_safe=true), without first consuming model turns. When the directory is not trusted, project-layer MCP servers are stripped, project skills load with a trust flag, and the TUI prompts interactively about projects with extension surfaces before starting.

Provider Configuration

Model provider, endpoint, model, and runtime parameters live in settings.json; API keys live in credentials.json; you can also use environment variables or auth login to import credentials:

kcoder auth login --provider kunlunmeta
kcoder auth login --provider anthropic

For development debugging, use KCODER_BINARY_POLICY (debug, build, or latest) and KCODER_RELEASE_BIN_DIRS to control binary sources; shared launch logic lives in scripts/install/lib/launcher.sh (binary policy, config migrate/import, credential import).

Architecture Overview

Rough data flow for a conversation:

CLI / TUI
  -> Settings + provider selection + MCP/plugin discovery + trust gate
  -> QueryEngine
  -> system prompt: project instructions + active skills + memory + tool definitions
  -> Provider streaming response (SSE, retry, incremental tool_use p

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [KunlunMeta-dev](https://github.com/KunlunMeta-dev)
- **Source:** [KunlunMeta-dev/Kcoder](https://github.com/KunlunMeta-dev/Kcoder)
- **License:** MIT
- **Homepage:** https://github.com/KunlunMeta-dev/Kcoder/releases

Install and usage instructions live in the source repository linked above.