- Rust 74.1%
- TypeScript 15.6%
- JavaScript 5.6%
- CSS 4.6%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
|
Some checks are pending
Quality / quality (push) Waiting to run
Co-authored-by: CommandCodeBot <noreply@commandcode.ai> |
||
| .github/workflows | ||
| docs | ||
| evals/tasks | ||
| scripts | ||
| src | ||
| src-tauri | ||
| tests | ||
| updates | ||
| .gitignore | ||
| AGENTS.md | ||
| KOLORA_HARNESS_AUDIT.md | ||
| package-lock.json | ||
| package.json | ||
| README.md | ||
| tsconfig.json | ||
| tsconfig.web.json | ||
| vite.config.ts | ||
Kolora
A desktop coding agent with a Rust runtime and Tauri 2 shell, plus a React/TypeScript interface. Electron and the Node agent runtime have been removed. Node is used only for frontend development and build tooling.
The Rust backend owns provider streaming, the agent loop, approval gates, session storage, filesystem tools, shell processes, embedded WebKit browser automation, screen captures, and native desktop input.
Requirements
- macOS or Linux; Windows desktop tools are not supported.
- A stable Rust toolchain, Node.js 20.19+ (or 22.12+), and npm. Installing skills from the marketplace additionally needs Node.js 22.20+ and
npx. - On macOS: Xcode command line tools. On Linux: Tauri's GTK/WebKit development libraries, PipeWire development headers (
pipewire-devel/libpipewire-0.3-dev), Clang/libclang (clang-devel/libclang-dev, needed byxcap's bindgen step), GBM/EGL/Wayland development headers (mesa-libgbm-devel,mesa-libEGL-devel,wayland-devel/libgbm-dev,libegl-dev,libwayland-dev). On Fedora:sudo dnf install pipewire-devel clang-devel mesa-libgbm-devel mesa-libEGL-devel wayland-devel. See the Tauri prerequisites. - The embedded browser uses WKWebView on macOS and WebKitGTK on Linux. No separate Firefox installation is required.
- Either a Command Code account/API key, a local Codex installation signed in with ChatGPT, or an API key for any of the bundled providers (DeepSeek, OpenRouter, Claude, Google AI, Cerebras, Mistral, Venice, OpenCode Zen, Inception) or a custom OpenAI-compatible endpoint with a model supporting tool calls through
/chat/completions. Screenshots also require a vision model.
npm install
npm run dev
Command Code is the default provider. Open Einstellungen → KI-Verbindung and pick a service in the Anbieter dropdown: that panel stores the API key (and the base URL only for a custom endpoint). Keys are stored in a local keys.json file that only your user can read (mode 0600), not in the macOS keychain, so Kolora never shows a password prompt. Command Code also accepts the key from your existing Command Code CLI login (~/.commandcode/auth.json) or a key from Studio. Every provider keeps its own key and model, so switching back and forth does not lose settings; the dropdown marks each service as Verbunden or Nicht verbunden, and unconfigured providers stay hidden in the composer picker.
A rejected key is reported in the chat. When a request fails (for example an expired Command Code CLI login, a missing key, or a provider HTTP error), the cause is saved as a red entry in the transcript and the provider's own message is shown. The run never ends silently with an unanswered user message. Run cmd login to refresh an expired Command Code CLI login.
Multiple keys per provider rotate automatically. In the same panel, paste another key to add it to the pool; each provider lists its keys with a delete button. The secrets stay in the 0600 keys.json, only the display labels are written to settings.json. Kolora starts with the key that last worked and switches to the next one when a request is rejected with HTTP 401, 402, 403, or 429 (including invalid-key and quota errors). The working key is remembered, so later requests start there instead of retrying a dead key. Rotation is bounded: at most three transport attempts per logical request and one visit per key. Cancellation interrupts backoff, a parseable Retry-After is honored within the request deadline when the request stays on the same key (key rotation may proceed immediately), malformed or context-overflow requests are not rotated, and a response that already emitted text or tool fragments is reported as interrupted instead of replayed. Model discovery keeps the same key order but is a separate GET loop; the three-attempt chat bound does not apply to discovery.
Reasoning that a model returns is shown in the transcript in a small collapsible Denken line above the answer (collapsed by default, click to expand). It streams in live while the turn runs and is stored on the assistant message, so models that require their earlier reasoning get it back on the next turn.
The model and the reasoning effort are chosen in the composer, in the two pills under the input field. The model pill opens a searchable list of every connected provider's models and switches the provider when you pick a model from another one; the reasoning pill sets Default, Low, Medium, High, or Max for the active provider. Those pills are what the next request actually uses.
Open Einstellungen → ChatGPT / Codex to use your existing local Codex login and ChatGPT plan usage. If necessary, click Mit ChatGPT anmelden and complete the browser login. The account panel keeps the Codex model, reasoning effort, and speed, then Speichern. The account panel displays remaining percentages and reset times from Codex; unavailable usage data is shown explicitly. API-key authentication never counts as a ChatGPT-plan connection.
The integration runs the official codex app-server over private stdio. It finds codex on PATH, in standard Homebrew paths, or bundled inside the ChatGPT/Codex desktop app. Set KOLORA_CODEX if your executable is elsewhere. Credentials and token refresh remain in Codex's credential store; Kolora does not copy access tokens into settings or send them to its React interface. Login is shared with your local Codex clients.
Select Eigene API (OpenAI-kompatibel) in the provider dropdown to keep using the original provider mode, and configure the base URL and key. The model comes from the composer picker, which queries that provider's /models endpoint. API usage has separate provider billing. The launcher also finds standard rustup installations in ~/.cargo/bin when the launching application has an older PATH.
Build and test
npm run build:ui # TypeScript check and production frontend bundle
npm run build # production native executable
npm run dist:mac # macOS DMG (build on macOS)
npm run dist:linux # Linux AppImage (build on Linux)
npm test # Node UI tests plus Rust unit and mock-provider tests
npm run test:browser # native browser integration test; opens an isolated test window
npm run eval # live evaluation when a key is set; eval:dry validates fixtures
npm run test:codex # live Codex smoke test; uses one turn of ChatGPT quota
npm run check:rust # Clippy, including test targets, with warnings treated as errors
npm run sign:mac # sign src-tauri/target/release/Kolora.app with an Apple Development identity
API keys are never read from the macOS keychain. An unsigned or ad-hoc signed build cannot pin keychain access, so macOS would ask for your password on every read; the key file avoids that entirely and is readable only by your user account.
The browser smoke test opens a local fixture, snapshots controls, types Unicode text and clicks through native WebKit input, verifies trusted click events, scrolling, tabs, history, reload, cancellation, browser screenshots and denial of application RPC from a remote page. It opens an isolated app window and temporary data store; it does not use your browser profile, model quota, or OS keychain entries. The default suite tests file tools including exact-match edits, shell timeouts and cancellation, session persistence, plan-mode tool filtering and write blocking, streamed tool-call assembly, permission denial, remembered approvals within one run, cancelling/resuming a multi-tool conversation, Codex stdio message routing, account-mode detection, and Codex chat resumption. Tests use temporary data directories and a local mock provider; they do not send model API requests.
Updates
Installed release builds check the signed update manifest at updates/latest.json once at startup, within a ten-second timeout. The prompt shows the installed and available versions; Update installieren downloads the platform bundle, verifies its signature, replaces the installed app, and relaunches it. Users do not need Git, Node, or a compiler. Linux updates use the AppImage bundle and macOS updates use the app bundle. Debug builds and release binaries run from their source checkout skip the check.
The Tauri public key is pinned in src-tauri/tauri.conf.json. Keep the private signing key outside the repository, for example at $HOME/.config/kolora/updater-signing.key, and back it up: losing it means existing installs cannot receive future updates. The dismissed version is remembered so the same prompt does not repeat. Turn the check off with Einstellungen → Verhalten → Beim Start nach Updates suchen (checkUpdates in settings.json).
To publish an update:
- Bump the version in
package.json,src-tauri/Cargo.toml, andsrc-tauri/tauri.conf.json; update the checked-inupdates/latest.jsonafter building. - Build with
TAURI_SIGNING_PRIVATE_KEYset to the private key path. Tauri emits the platform updater bundle and a matching.sigfile. - Upload the bundle and
.sigto the matchingv<version>release on the Git host. - For Gear Lever and AppImageUpdate,
npm run dist:linuxembedszsync|https://git.new-eve.org/axoisaxo/kolora/releases/download/continuous/Kolora-x86_64.AppImage.zsyncand writesKolora-x86_64.AppImageplus its.zsync. Upload both to the sharedcontinuousrelease on every update; the stable names and the zsync URL stay the same, so installed AppImages can update in place. The signed Tauri manifest remains the in-app updater path. - Generate the manifest with every released platform, for example:
npm run update-manifest -- --version 0.2.1 \
--artifact linux-x86_64=src-tauri/target/release/bundle/appimage/Kolora_0.2.1_amd64.AppImage \
--artifact darwin-aarch64=src-tauri/target/release/bundle/macos/Kolora.app.tar.gz
The script reads each artifact's .sig file, writes updates/latest.json, and defaults asset URLs to the matching release tag. Commit the manifest after the release assets are reachable.
Structure
src-tauri/src/main.rs desktop entry point (thin); Tauri lifecycle
src-tauri/src/desktop.rs Tauri builder, RPC dispatch, legacy-data migration
src-tauri/src/lib.rs the core library shared by both binaries
src-tauri/src/bin/kolora-exec.rs headless runner (one task, no desktop)
src-tauri/src/browser_host.rs BrowserHost trait, headless host, spawner
src-tauri/src/agent.rs Engine, approvals, cancellation, tool dispatch
src-tauri/src/runtime/ Goal/contract, ledger, verification, policy, critics, context, report
src-tauri/src/provider.rs HTTP provider and SSE parsing
src-tauri/src/codex.rs private Codex app-server process, auth, models, usage
src-tauri/src/codex_run.rs Codex turns, resumption, dynamic tools, interruption
src-tauri/src/store.rs atomic JSON persistence and 0600 key file
src-tauri/src/browser.rs embedded WebKit tabs shared by user and agent
src-tauri/src/tools.rs tool schemas, filesystem, shell, screenshots, desktop input
src-tauri/src/agents_doc.rs workspace AGENTS.md discovery and prompt section
src-tauri/src/skills.rs skills.sh catalogue search, installs, and leaderboard proxy
src-tauri/src/skill_runtime.rs installed Agent Skills discovery, matching, and auto-loaded prompt section
src-tauri/src/harness_skill/ built-in harness skill, embedded and installed on first start
src-tauri/src/web_search.rs SearXNG → DuckDuckGo Lite → keyless Firecrawl search
src-tauri/src/adapta.rs virtual provider lane routing for the developer Adapta model
src/renderer React interface
src/renderer/src/lib/native.ts typed Tauri bridge exposing window.rc
src/shared frontend message and API types
Runtime behavior
-
Addon Marketplace → Skills browses and searches the public skills.sh catalogue from the Rust backend, so the desktop webview does not need cross-origin access. It shows the site's current leaderboard, offers topic shortcuts, links each skill to its skills.sh page, and installs skills directly through the official
npx skills addCLI. Installations go either into the selected project's.agents/skillsdirectory or globally when Global is selected; the panel also lists what is currently installed. The install button requires Node.js 22.20 or newer withnpxavailable. -
Installed Agent Skills are discovered from user-level
~/.claude/skills,~/.commandcode/skills,~/.agents/skills,~/.config/agents/skills, and~/.config/kolora/skills, plus every.claude/skills,.commandcode/skills, and.agents/skillsdirectory from the repository root down to the working directory. A project skill wins over a user skill with the same name. The agent can install skills itself with theskill_searchandskill_installtools, which use the same project or global universal directories and respect theexecpermission. The marketplace and/menu refresh after installs and after each agent run. Every installed skill also appears as/<skill-slug>in the composer's/menu; invoking it injects the fullSKILL.mdbody for that turn, expands$ARGUMENTSand skill/project path placeholders, and keeps the original slash command in the transcript instead of showing the hidden prompt. The system prompt contains each skill's name, description, andSKILL.mdpath; matching skills are also selected automatically from the request and their bodies are inlined (up to three skills and a bounded byte budget), so a relevant procedure is followed without a slash command. The built-inkolora-harnessskill is installed automatically into<config>/kolora/skills/kolora-harnesson first start, always listed (shown as Integriert), and loaded for every request; it documents the tool set, the quality runtime, the preview/fixture behavior, browser limits, and visual verification. Settings → Verhalten can turn skills off (loadSkills). -
The desktop shell is locked to 100% page zoom. ⌘/Ctrl +/−, ⌘/Ctrl + scroll and trackpad pinch do not scale the interface, because WebKit page zoom shrinks the CSS viewport and clips the fixed multi-pane layout. Zoom hotkeys are disabled in the window config and the macOS webview rejects magnification; text and layout scaling follow the OS display settings.
-
Type
/planmodus(or/and pick the command) to switch a chat to plan mode: the agent only receives read-only tools, and a hard block rejects writes, commands and desktop input even if permissions allow them./buildmodusswitches back; Plan ausführen applies the plan in build mode. -
Visual criteria are checked at the exact viewport they declare: the capture matrix adds contract viewports to its default breakpoints, and a UI task without an explicit reference is served from a top-level
index.html(or the single changed HTML file). Avisualcriterion automatically runs the visual critic, sofinishis not blocked waiting for a review that would never start. The prompt and built-in harness skill state these rules, and an identical failing tool call is blocked after two attempts instead of being retried indefinitely. -
The prompt includes the current UTC time, and the built-in
kolora-harnessskill requires live verification for time-sensitive facts such as AI models and versions, product releases, prices, availability, news, and rankings. In the desktop app the agent searches with the embedded browser (for example a DuckDuckGo query followed by a snapshot) and cites the source date; no search API key or subscription is involved. -
Public web research needs no contract:
browser_openandweb_fetchmay read public HTTP(S) pages, while private, link-local, and.internalhosts stay behind a declared research source. Browser input andbrowser_evalremain limited to localhost, workspace files, and declared origins, so opening a search page cannot turn into blind clicking on an untrusted site. -
Every run shows a live clock ("Arbeitet … 2m 30s") and, once it settles, a muted line at the end of the turn: "Gearbeitet für 2m 30s". The duration comes from the renderer's run timer and is kept per chat for the app session.
-
/statusshows the remaining quota for the active provider (Codex 5-hour and weekly windows when the plan exposes them) and token usage otherwise. Cached-input and cache-miss counters are shown only when the provider reports them; unsupported or partial data is labeled as not reported rather than zero. -
File tools cover
edit_file(exact-match replacement with a diff),delete_fileandmove_filealongsideread_fileandwrite_file. -
In Codex mode, chats persist their Codex thread IDs and resume them on the next turn. Changing accounts or switching between API and Codex imports the visible conversation into a fresh Codex thread as needed. Authentication errors never trigger an automatic switch to API billing.
-
Workspace instructions come from the user-level
<platform config dir>/kolora/AGENTS.md(for example~/.config/kolora/AGENTS.mdon Linux; override the directory withKOLORA_HOME) and everyAGENTS.mdfrom the repository root down to the working directory, with the nearest file taking precedence. Settings → Verhalten can disable loading them and lists the files detected for the default working directory. -
Some OpenAI-compatible DeepSeek gateways stream the model's native DSML tool-call markup in the text content instead of
tool_calls. Kolora parses that markup back into normal tool calls, so the call executes and no raw token text reaches the transcript. A200response that is not valid JSON (a proxy HTML page or a truncated body) is retried; if it persists, the error names the HTTP status and shows a body excerpt instead of a bare decode error. Transient transport failures (DNS, refused or reset connections, dropped bodies, and timeouts) are retried with backoff before the run reports an error. -
Codex receives namespaced Kolora dynamic tools, so filesystem, shell, browser, and desktop calls go through the same live permission checks and approval cards as API mode. The Codex execution environment is read-only, native shell access is disabled, and unsupported native privilege requests are refused. Dynamic tools require a compatible recent app-server version; the CLI schema is experimental.
-
The browser panel splits the workspace 50/50 and embeds real WebKit tabs. You can click, type, select text, scroll and play media directly. The agent reads and controls those same tabs using the existing browser tools;
browser_tabsopens, switches and closes them. -
Desktop pages that keep a wider minimum layout than the panel (Google Search, for example) are scaled down slightly to fit instead of forcing horizontal paging. The adjustment is applied at load and on resize only when the content overflows by 2–60 %, so ordinary pages are untouched.
-
Browser pages render directly in native child webviews; there is no screenshot polling or remote-debugging port. On Linux the native view is placed on a GTK overlay above the interface, so it fills exactly the panel rectangle instead of sharing the window with the app; on macOS the child webview is positioned directly. Agent snapshots read the active page through host-side JavaScript evaluation, input targets the native browser surface, and screenshots are captured on demand through WebKit. Browser actions keep the existing live permission and plan-mode checks. The panel opens when the agent uses browser tools; native input requires a visible app and browser panel, and is refused while the page is hidden by a dialog. Remote pages receive no application capabilities, cannot invoke application RPC, and do not receive agent/session events. HTTP(S), the empty
about:blankpage, and regular files inside the active workspace are allowed. A workspace file can be opened by absolute path orfile://URL, so static HTML and other local pages preview without a local web server; paths are canonicalized and may not escape the workspace. Browser data belongs to the app’s WebKit store, independently of Safari, Chrome or Firefox profiles. -
Projects can be dragged the same way: pinned projects stay above unpinned ones, and a drop across that boundary is refused, so the pin group keeps leading the list (the order inside each group is stored in
kolora:project-order). Chats can be reordered inside their project by pressing anywhere on a chat row and dragging it; the cursor turns into a grab hand while dragging and an accent line shows the insertion point. The order is kept in the renderer's local storage (kolora:chat-order) and survives restarts; chats that were added later follow after the ordered ones. -
Öffnen in sits at the left of every chat header: it opens the project folder in the detected file manager (Finder on macOS,
xdg-openon Linux) or in an installed editor. Editors are detected from/Applications,/System/Applicationsand~/Applicationson macOS (VS Code, Cursor, Zed, Sublime Text, Xcode, JetBrains IDEs, TextEdit, …) and fromPATHon Linux; only installed apps are listed. The same menu offers Pfad kopieren for the project path, and the project right-click menu has Im Finder zeigen / Im Explorer zeigen plus pinning and a new chat. -
Projects, chats and models can be pinned. Right-click a project to pin it and it jumps to the top of the sidebar; right-click a chat for rename/delete; hover a model row in the composer picker and click its star to move it into the Favoriten section. All menus are single-column popups that close when you click anywhere beside them. Pins live in the renderer's local storage (
kolora:starred-projects,kolora:starred-models). -
The right panel mixes browser tabs with tool tabs: Dateien (expandable file tree with git status and a syntax-highlighted preview for Markdown, JSON, HTML/XML, CSS, YAML/TOML/INI, JavaScript/TypeScript, Rust, Python, Go, Java, C/C++, C#, Swift, Kotlin, Ruby, PHP, shell, SQL, Lua, R, Dart, Scala, Elixir, Haskell, Dockerfile, Makefile, TeX and diffs; the header names the language and line count, unknown types stay plain, and binary or oversized files show a short note), Änderungen (structured diff plus a visual Git console: branch switcher with new-branch creation, stage/unstage, commit message, fetch/pull/push with ahead/behind counts, and repository setup for projects without Git that can either initialize a new repository or clone one into an empty project folder), Terminal (real zsh/bash session) and Kontext (session, provider, model, context limit, token usage, cache-hit/miss counters when reported, cost, timestamps, and raw message IDs). Its start page lists Browser, Dateien, Änderungen, Terminal and Kontext, and the + button always sits directly to the right of the open tabs. Sitzung exportieren in the context tab writes the session as pretty-printed JSON to
~/Downloadsand shows the resulting path. -
Einstellungen → Erscheinungsbild offers the presets Grau, Gelb, Blau, Lila and Grün plus Blau (Effekt) (an exact copy of the blue preset whose background is the non-interactive glyph-water field from kolora.dev), Hacker (black UI with a non-interactive green
#20C20EMatrix rain), Winter (cozy night-blue surfaces with snow), Aurora (drifting northern lights), Sakura (rose palette with falling petals), Glut (warm embers rising from the bottom), Ozean (petrol and turquoise with bubbles), Herbst (rust, gold and olive with drifting leaves), Kosmos (star field with shooting stars), Regen (cool blue-gray rain), Glühwürmchen (moss green with glowing points), Neon City (magenta/cyan grid and scanlines), Frost (icy edges and crystals), Kaffee (espresso with drifting steam), CRT Amber (amber terminal with scanlines), Mono (neutral black/white) and Pixel Night (8-bit stars and a pixel moon). The Hell group contains Papier (warm paper, ink and grain), Tageslicht (clear white with cool blue), Sand, Minze, Himmel, Flieder and Pfirsich; the picker separates dark and light palettes, and Alle Farben anpassen opens the custom editor. Logo tiles keep the exported Figma 60% corner smoothing and the marks invert automatically in light mode; dedicated light assets can replace them later. Presets tint the canvas, cards, inputs, lines, right panel and terminal toward the accent while text stays neutral. The selection above is always the base palette; Alle Farben anpassen stores only individual overrides on top of it. Existing custom settings still load and remain editable. Menge (Textmenge, Schneemenge, Blütenmenge, Funkenmenge, Blasenmenge, Blättermenge, Regenmenge, Glühwürmchen, Sternenmenge) and Vor der Oberfläche are shown only for particle themes and control that field there; Blau (Effekt) and the CSS-only themes always stay behind the UI without controls. -
Agent runs play bundled completion and failure cues. Sounds bei Abschluss und Fehler abspielen in Settings → Verhalten toggles them. A 0–100 % volume slider and Abschluss/Fehler preview buttons live in the same section. The WAV/AIFF sources live in
src/renderer/src/assets/sounds; sound updates are sourced from the user'sSoundsfolder, transcoded to WAV when needed, and mapped insrc/renderer/src/lib/sounds.ts. -
Bilder an den Agenten: paste an image into the composer, drop PNG/JPEG/WebP files onto the window, or press ⌘⇧S anywhere in the app to drag a screen region or window; the capture appears in the composer and is sent with the next message. Attachments are stored in the app data
capturesdirectory, previewed as thumbnails, and can be removed before sending. The interactive selection is macOS-only. -
On macOS, closing the main window cancels the current run and hides the window. Reopening from the Dock shows the same window and runtime, preserving valid browser references. Quit exits the application.
-
write_file,run_command, andcomputerhave ask, auto, or deny permission modes. Every tool call in both the manual and quality loops reads the current permission mode. Configured ask waits for the existing session+call approval card, deny blocks before any side effect, and remembering an approval updates settings before releasing the waiting call. Hard plan, scope, sandbox and security denials are never converted into approval prompts. -
Cancellation aborts HTTP requests and kills shell process groups. Every unanswered tool call receives an interruption result before the session is saved, so the conversation can be resumed. Old interrupted transcripts are repaired on their next run too.
-
Tool results are written before screenshot attachment messages, including for multiple calls in one assistant turn.
-
Session changes are blocked while a run is active. Events carry a session ID, so late events cannot append messages to a different open session.
-
Repository checks and agent shell commands run in a private worker environment: resolved toolchains, private 0700 HOME/TMPDIR, a sanitized allowlisted environment, and an explicit sandbox policy. Ambient CARGO_HOME/RUSTUP_HOME roots, host dotfiles and credential variables are not inherited. The macOS xcrun compiler cache in the platform temp root is the only narrow temp exception.
-
Screenshots for the agent use Rust's
xcap; macOS requires Screen Recording permission, and a failing capture is reported in the tool result. Interactive attachments callCGRequestScreenCaptureAccessso Kolora is registered in the Screen & System Audio Recording list; if macOS still hides it, use the error banner's App zeigen action and add the bundle with+. Native input requires Accessibility permission. Input actions are advertised according to the detected backend.
| Platform | Input backend | Actions |
|---|---|---|
| macOS | osascript, optionally cliclick |
typing and keys; pointer actions with cliclick |
| Linux X11 | xdotool |
pointer, typing, keys, scroll |
| Linux Wayland | wtype |
typing and keys |
Quality runtime
See docs/harness/quality-report.md for the measured offline suite, fixtures, and known limits.
Provider replies preserve their raw stop reason and transport completeness. A normal completion, tool handoff, output-limit stop, content filter/refusal and incomplete stream are distinguished before any effect; truncated or malformed tool arguments, duplicate or missing IDs, and unknown stops are rejected instead of being turned into {} calls. Private extension metadata such as reasoning_content stays internal and is never shown as answer text.
Every assisted or unattended native-loop run creates a Goal before changing anything; manual mode keeps the previous single loop with approvals. The Goal is persisted with the session, versioned on refinement, and turned into a typed contract: criteria, scope, research sources, assumptions, risk, and task class. The same contract call also returns the initial plan, so planning does not add a second model round trip. Recoverable contract mistakes are repaired: missing criterion fields become safe evidence checks, and an unsupported ad-hoc command is verified as command evidence rather than treated as a project check. If the contract model still returns nothing usable after one retry, the runtime creates the Goal and a deterministic plan from the user's request so the run can start. Until the contract is accepted the model only receives read-only tools. The run records a baseline, implements, verifies, critiques, and asks the harness whether the Goal is met. The model's "done" is a proposal, not the decision.
The desktop chat keeps a compact Aufgaben checklist in the Agentenstatus dock above the composer. Each plan step is one short bullet with one of four states: Erledigt, Wird bearbeitet, Offen, or Blockiert. The full Goal contract, checks, critiques, and final report remain internal to the runtime and headless output.
-
Evidence is durable. A payload is synced before its index record; each JSONL record is appended as one buffer and
sync_datacompletes before acknowledgement, with a containing-directory fsync when the file is created (Unix). Only a missing ledger creates an empty one. A single torn final line is quarantined byte-for-byte and the parsed prefix is audit-only; interior corruption, missing/tampered payloads, escaping payload paths and unreadable ledgers block effects and verified completion until a reviewed repair. Recovery never appends beyond a torn tail or silently replaces history with an empty file. -
Evidence is binding. Every tool result becomes a ledger record (
ev_0001) with a SHA-256 digest.finishmust cite evidence and bind every nonempty blockingEvidencecriterion withcriterionEvidence(criterionId,evidenceIds); the host validates the criterion, attempt, kind, freshness, non-rollback state and payload digest. A related file/check citation is deterministic; a nonobjective research citation is marked reviewed and remains subject to the independent critic panel and Goal decision, so arbitrary prose is never called mechanically proven. Unsourced numbers, private URLs, secrets, home paths, stale or cross-attempt evidence, out-of-scope changes, and hidden unmet criteria are rejected before the report is accepted. Reports are built from the structured record, never from model prose. -
Verification is scheduled. The project profile pins checks from
package.json,Cargo.toml, and the check scripts. A rewritten script, a removed or ignored test, or a zero-test exit is rejected as evidence. Auto and Fast use a cheap compile probe during edits; Auto and Full run the complete profile before completion, while Fast runs checks for the touched area and any checks named by the contract. Documentation-only changes skip unrelated execution but never skip explicit contract criteria. A red baseline is recorded and reported, not blamed on the run. The Sandbox setting defaults tooff:run_checkandrun_commandthen run with the user's own privileges and network access. Set it torequireto run both insidebwrapon Linux orsandbox-execon macOS, or toautoto use a detected sandbox when one exists. Inassistedmode unsandboxed execution stays denied; inunattendedthe explicitoffsetting is treated as consent, while workspace scope, protected-path, plan-mode, network-install, and desktop-input gates remain active. When no sandbox is used, checks still strip credential-like environment variables before starting repository code. -
Git is optional and never gates agent work. In folders without Git, Git read tools return empty results and commands run normally. Kolora does not create automatic Git checkpoints, snapshots, rollback records, or rollback warnings. Git commands only happen when the user or agent explicitly runs them. Deleted and overwritten files go to the app-data trash; retention is 7 days or 20 runs, whichever is longer.
-
Completion is a gate. Deterministic criteria run first, then the critic panel, then the Goal review. Independent critics run concurrently, and deterministic check, claim, plan, and evidence failures short-circuit before model-based review. The default review re-evaluates every criterion and consumes the requirements critic. Set Einstellungen → Agent → Entscheidungsmodell (for example
jev) to use a fresh-context Goal Judge instead; it must cite evidence, cannot waive a hard gate, and falls back to harness+critic on error (decision: fallback). Eachfinishattempt opens a fresh review round, so a verdict from an earlier attempt cannot outlive the change that fixed it, and a critic objection that names no file, criterion, or evidence is recorded as advisory instead of blocking completion. A run ends on accepted completion, user cancellation, or a real budget/provider failure. Read-only exploration and rejectedfinishattempts receive nudges and blockers; there is no arbitrary no-progress or review-count stop. -
Budgets are one root account. Parent, implementer children, critics, the judge, compaction and retries share one cumulative token/tool/wall/cost account for the task; child usage is settled once, never merged twice. Before concurrent inference the harness reserves estimated input and requested output against finite cumulative caps, settles actual usage exactly once and releases unused reservations on completion, failure or cancellation. Verification/critic reserve fractions apply only to finite
max_input_tokens/max_output_tokens, never to the context window; unlimited token caps are reported as not enforceable. Known cost is a subtotal with an explicit completeness flag, andmax_cost_usdwithout a verified price source stops cost-bounded work instead of inventing a guarantee. -
Checkpoint restore is explicit. Backend RPCs
checkpoints:previewandcheckpoints:restoreexpose the persisted attempt checkpoint to the user, never automatically. A preview returns per-path operation plus current/target digests and marks existing-but-different bytes as a conflict. For Git it enumerates the checkpoint plus current status paths, so run-created/modified files are selectable; requested paths outside the checkpoint are refused. It is bound to the session, artifact attempt, workspace and an expired-in-60s single-use token (max 32 pending). Restore requires explicit confirmation, refuses an active owning run, rechecks the current artifact attempt, accepts only previewed paths, requires explicit conflict acknowledgement, and verifies the previewed digest throughRevisionBasisunder the mutation lock (so an intervening edit fails instead of being overwritten). Writes/deletes go through the mediated mutation service with app-data trash, mutation lock and phase-18 leases; a durable restore receipt and a system message require re-verification.sessions:rewindremains transcript/ledger-only. No automatic restore, no force override, no silent conflict resolution. -
Checkpoints precede mutations. Before the first admitted write/edit/patch/delete/move/shell/implementer mutation in an attempt, the Runner creates a persisted checkpoint with the existing bounded snapshot machinery: Git repos use a temporary index and private ref without changing the user's HEAD, index or branch; non-Git workspaces snapshot the scoped preimage and add new paths before overwrite. Snapshot capacity failure blocks the effect instead of claiming recoverability. Reports carry the real checkpoint ID plus attempt/workspace identity; child imports stay under the parent checkpoint boundary. Conversation rewind remains transcript-only. Restore preview/approval is exposed through the explicit checkpoint panel; rename and reverse operations remain later work.
-
Experimental parser-assisted map (off by default). The non-default Cargo feature
experimental-parser-mapindexes Rust and TypeScript/TSX definitions/imports with pinnedtree-sitter 0.25.10,tree-sitter-rust 0.24.2andtree-sitter-typescript 0.23.2(all MIT). Parse trees are bounded (5,000 nodes/250 ms/512 KiB input); parse errors, unsupported languages, cancellation and resource caps fall back to the phase 27 heuristic extractor. Entries carry additiveprovenance(parser/heuristic) andconfidence; the default build compiles no tree-sitter C code. Task-symbol ranking only affects the remaining map entries after explicit scoped/referenced paths, under the same 6,000-character budget; no semantic call-graph claim. No paid retrieval comparison exists and the feature stays off. -
Experimental scoped-explore loop (off by default). Building with the non-default Cargo feature
experimental-scoped-exploreletsRole::Explorechildren use onlyread_file,list_dirandsearch_filesthrough a bounded loop: at most 3 inference rounds, 8 admitted tools, 16,000 returned characters, the remaining root budget/deadline and cancellation. Paths must resolve inside the explicitly validated workspace scope (~, traversal, workspace escapes and canonical-scope symlink escapes are denied); shell/write/browser/spawn/finish tools are never advertised or dispatched, normal policy admission still applies (interactive approval is denied instead of waiting), each dispatch charges the shared root tool counter, and no child credential is added. The result is the existing compactAgentResultartifact; findings must cite an observedpath:lineand the current full-file SHA-256, and unverifiable findings are omitted (all-fabricated findings fail the child). The default build keeps the static bundle/no-tools path unchanged. No default setting/UI toggle, and no performance claim without matched phase 26 data. -
Repository maps are bounded and task-selected. The quality Runner builds a map lazily only for file/code work, with caps of 10,000 candidate files, 64 MiB source bytes, 1,000 ms, 512 KiB per file and cancellation. Git repos use ignore-aware
git ls-files; non-Git uses bounded walkdir without symlink traversal, with reduced ignore semantics documented. Selected entries are revalidated by raw SHA-256 content digest (mtime/size are only hints), so same-metadata edits invalidate. The outline ranks explicit scoped paths, referenced imports/tests, then deterministic lexical order, and is capped at 6,000 characters by default; truncation and incomplete scans are labeled. The map is appended only to the trailing runtime context when used; the stable system prefix and conservative smalltalk path stay unchanged. There is an internal off switch for ablation; no Tree-sitter/LSP. -
Fast paths preserve the gate. The quality Runner freezes the system instructions, tool schemas and capability snapshot for the run. Goal, criteria, scope, plan, checks, blockers, evidence, clock and budget are sent as a trailing hidden runtime message, so the provider-cacheable prefix stays byte-identical across turns. Workspace
AGENTS.mdand installed-skill prompts are refreshed only when those files change. Older tool output and screenshots are pruned to evidence references, unavailable browser/desktop/image tools are omitted from the request, and up to eight independent file/git reads run in parallel. Writes, shell commands, and session mutations remain serial. The model still must satisfy the same evidence, check, critic, and report gates. -
Conversational turns stay cheap. Obvious greetings, thanks, and short acknowledgements skip the Goal/contract, tool loop, and critic panel and use one provider call; anything that looks like a task still goes through the full quality runtime.
-
Desktop tasks are declared.
computerandscreenshot_desktoprequire a contract research source withkind: "desktop"and a non-empty target window description; the statement alone is not permission. -
Autonomy is a policy, not a prompt.
unattendedallows reads and in-scope writes; desktop input, untrustedbrowser_eval, and network installs are denied with a reason and the model adapts. With the sandbox explicitlyoff, unattended execution ofrun_commandand pinned checks is allowed;assistedstill denies it.autoresolves to unattended when no execution is needed or a sandbox is available, and to assisted for execution without a sandbox.manualkeeps the previous approval flow. -
Merging stays manual.
autoMergeis reserved and off; merging tomainremains an explicit policy boundary (AGENTS.md requires approval). -
Subagents are capped at depth 1 and concurrency 4. Explore/verifier/critic/visual children run with a fresh read-only context and per-role allowlists. Implementer children run in an isolated git worktree under a write lease, are cancelled with the parent, and return a patch that the parent applies only after a scope and conflict check. Provider-owned Codex turns get a post-turn baseline/check audit, but their Goal contract remains advisory because Codex owns the turn.
-
Headless execution.
kolora-execlinks the same library with the desktop feature off:cargo build --manifest-path src-tauri/Cargo.toml --no-default-features --bin kolora-exec KOLORA_API_KEY=… ./src-tauri/target/debug/kolora-exec \ --task task.md --cwd ./project --out ./run --json --autonomy unattendedExit codes:
0Goal met,1not met,2runtime/configuration error,3blocked by policy or a missing capability. It never opens the desktop app and reportsbrowser_unavailable; a browser or visual task cannot be claimed in a headless run.--decision-modeland--decision-providerselect the Goal Judge. -
Evaluation comparisons are paired and unranked.
scripts/eval/compare.mjsvalidates captured phase 24/25 observations before analysis: pairs are matched by task/repeat/seed, model/provider/reasoning/tools/instructions/worker/limits/evaluator must match except the preregistered treatment fields, and missing/incompatible/infrastructure pairs are excluded from the primary comparison while every assigned attempt remains counted. Independent success, tokens/cache, tool attempts/dispatches, wall time, conflicts/partials/context recovery and known/unknown cost are reported with denominators. Task-level paired means use equal task weight; uncertainty is a task-cluster percentile bootstrap (10,000 resamples, seed 20261030, all repeats intact). Zero successes or incomplete cost makes cost-per-success undefined, never zero. No ranked or universal-winner claim is emitted, and no paid result is claimed without independent execution. -
Evaluation grading is independent. Evaluator definitions (
task.md,checks.json, setup/reference) are frozen in a trusted directory and fingerprinted before solve; the solver sees only its workspace and task input. After capture, a pristine workspace is rebuilt from the trusted initial snapshot and only the recorded solver patch is applied with exactgit apply --check/git apply(no fuzzy/three-way/force). Reserved/evaluator paths, traversal and symlinks are rejected. Trusted shell/file assertions run in a fresh process with an isolated home, no solver credentials, and network denied bysandbox-execon macOS; reportgoal-met-style criteria remain product diagnostics, never independent success. The versionedgrade.jsonrecordsevaluatorDigest,patchApply, independent checks and an explicit status (passed,solver_error,timeout,exact_apply_failure,grade_failure,infrastructure_failure). Evaluator files are frozen outside the attempt and rehashed before grading; the patch must match the captured hash;run_commandcwd outside the workspace is denied. Oracle/no-op/tamper controls run offline. -
Evaluation.
evals/tasks/<id>/containstask.md, optionalsetup.sh,checks.json, and an optionalreference.patchthat is never shown to the agent.npm run eval:dryvalidates fixtures offline;npm run evalwithKOLORA_API_KEYruns an isolated attempt. Every executed attempt is retained under the attempt root (evals/runs/by default, or--out) with a versioned manifest written before execution, provenance hashes, model/endpoint identity, settings/tool-schema hashes, limits, isolated workspace/data/input/captures, bounded stdout/stderr, report, solver patch and changed-file receipts. Failed/setup/timeout/spawn attempts are kept. The child runs with an explicit environment allowlist and isolatedHOME/XDG dirs; no developer config or key files are read, and the only intended credential is the assigned gateway environment variable (the legacy key migration path remains a documented limitation). SolvergoalDecision/claims are labeledself_reportedandgraded:false; no task-success claim is made before grading. The process exits nonzero when capture fails or evaluator checks fail, even if the solver self-reports a met goal.KOLORA_EVAL_TIMEOUT_MSand the test-onlyKOLORA_EVAL_EXECoverride are documented environment hooks. The runner never puts the reference patch in the agent's context.
Data and migration
New data lives in Tauri's application data directory for dev.kolora.harness (on macOS, ~/Library/Application Support/dev.kolora.harness). It contains settings.json, sessions/*.json, captures/*.png, artifacts/<session>/<uuid>.{txt,json} for bounded tool-output artifacts, runs/<session>/<attempt>/ sidecars (attempt manifest, goal, contract, plan, append-only ledger, checks, compactions, report, artifacts), and trash/. Each new quality task gets its own attempt directory; legacy runs/<session>/<session>/ records stay readable but are never reused or appended to. Settings and sessions are atomically replaced; session IDs are validated before constructing disk paths. Captures are served to the interface through Tauri's scoped asset protocol.
Kolora remembers its window position and size in window.json and restores them on the next start when the frame still overlaps a connected display; otherwise macOS places the window again.
On first launch, the app copies sessions, captures, and settings from the previous Kolora data directory (com.kolora.harness), the older ColorCode data directory (com.redcode.harness), and the original Electron redcode directory when present. It also copies the user-level AGENTS.md from the previous config directory. The migration only fills files that are still missing, so existing Kolora data always wins; the original files remain intact.
Re-enter your API key after updating from 0.3.1 or earlier. Earlier builds kept keys in the macOS keychain; Kolora no longer reads it, because every read asked for the keychain password on unsigned builds. Paste the key once under Einstellungen → KI-Verbindung (or run cmd login for Command Code) and it is saved to the 0600 key file. Electron safeStorage ciphertext and legacy plaintext keys from settings.json are still read until replaced.
Limits
- Unattended runs compact automatically at 80% of the context window (configurable 50–95%), with a 95% hard stop. The transcript stays canonical in the session; the wire context is derived. Compaction has no count limit: whenever the context reaches the threshold it summarizes and continues, and old tool output is pruned as needed; the run only stops at the real 95% context hard stop. Compaction covers an exclusive canonical prefix, never splits an assistant tool-call exchange, retains the newest user turn and unresolved calls, and stores a schema version plus canonical-prefix digest. If a single long turn has no safe prefix, compaction emits an error notice and continues only until the 95% hard stop; that turn is not compacted. Legacy checkpoints without proof remain audit artifacts; the derived context is rebuilt from canonical history instead of reusing them. A new summary candidate must be exactly one complete JSON object that matches the authoritative Goal, cites only fresh attempt evidence, passes pairing and canonical-prefix checks, and strictly shrinks the fully composed request; invalid, nonshrinking, timed-out or cancelled candidates leave the prior context unchanged. The immutable candidate sidecar is written before the session reference and the live wire. Before every quality-Runner request, the harness reserves output capacity (configured max output tokens, otherwise min(8192, window/8) floored at 1024) and admits the request only when the estimated input plus a 5% margin plus that reserve fits the effective window. It prunes, attempts one validated compaction, then uses a labelled emergency projection. A typed provider context overflow gets at most one smaller retry before the run stops with context_exhausted. There is no per-turn step limit; token, wall-time, and tool-call budgets bound the loop. The tool-call ceiling is admitted before each dispatch, including every member of a parallel read batch; refused calls settle with an explicit budget result and never execute.
- Manual mode keeps its single-loop behavior and approvals, but now uses the shared context admission: it prunes, may install a manual summary checkpoint, falls back to a labelled emergency projection, and stops with context_exhausted instead of the legacy 800k-character crash. Quality runs use the same admission boundary: configured Ask pauses, Deny blocks, and assisted risky actions wait for approval after hard scope/sandbox checks. Remembered approvals update settings only for the selected group.
- File mutations go through one mediated service: per-workspace normalized-path locks serialize cooperating writes, a captured raw-byte revision is rechecked before commit, containment/symlink escapes are revalidated, and trash snapshots plus mutation receipts preserve recovery. This is cooperative only; uncooperative external writers can still race between the recheck and rename, and shell/external writes are outside the guarantee. Mutated paths are workspace-relative; absolute paths inside the workspace are rejected by the service.
- Completion uses one truth table: a
CheckRunmust have trustedvalidity(proven) and the declared exit; zero-test, cancelled, timed-out, unavailable, truncated-inventory and unstable checks never pass. Blocking criteria block; advisory failures are reported as warnings. Explicit pending/in-progress plan steps block; a blocked step needs a visible resolution reason. - Verification reuse is bound to a bounded content fingerprint: relevant tracked/untracked inputs, the inclusion policy and live check definitions are hashed before and after a check. Cached green checks, evidence and
changedcaches are invalidated when the fingerprint changes; a scan that exceeds 20,000 files, 256 MiB or 5,000 ms fails closed. Generated outputs and credential files are excluded. apply_patchpreflights every section, snapshots backups without deleting originals, commits files sequentially, and reports applied/failed/unattempted/uncertain paths with a durable recovery receipt. Recovery is explicit and refuses any target whose bytes no longer match the recorded postimage.- Tool results dispatched through the shared manual/quality executor are bounded to 32 KB content and 64 KB serialized in the canonical transcript. Oversized or escape-heavy text is stored privately as a session-scoped SHA-256 artifact (8 MiB per artifact, 128 MiB per session) and can be read in 8 KB content ranges plus a small header with
read_tool_artifact; partial/quota/disk captures are marked incomplete. Internal runtime-generated messages keep their existing explicit truncation. Images remain images. - Shell output retained for the model and UI is capped. Shell streaming is also capped per stream at 120 KB (the oldest bytes are retained) plus one truncation marker; readers settle under a 250 ms normal drain or 1 s cleanup with abort/join, and truncated/cleanup-incomplete markers are explicit. Verification runs collect stdout/stderr concurrently under one 200 KB cap, preserve UTF-8 boundaries, mark truncation, and settle under one operation deadline (250 ms normal drain, 1 s kill/cleanup on cancel/timeout). Incomplete output/cleanup and truncated test inventories fail closed instead of producing a green zero-test result. Persistent servers should be explicitly backgrounded with output redirected to a file.
- Browser calls have bounded protocol/wait timeouts. Cancellation waits for an in-flight native browser/input/capture operation to return; it prevents subsequent calls.
- Screen capture support depends on OS permissions and the compositor/portal backend. Desktop input remains limited to the detected platform backend.
- On Linux,
npm run devneeds a free inotify instance for Tauri's file watcher. If startup printsToo many open filesor the inotify limit is exhausted, raise it withsudo sysctl fs.inotify.max_user_instances=1024(persistent:/etc/sysctl.d/99-kolora.conf).scripts/native.mjsdetects this case and prints the same hint instead of core-dumping. - On Linux, Kolora sets
WEBKIT_DMABUF_RENDERER_FORCE_SHM=1to avoid the WebKitGTKGdk-Message: Error 71startup crash while keeping the accelerated compositor and transparent windows. Do not setWEBKIT_DISABLE_DMABUF_RENDERER; on WebKitGTK 2.54 it disables window transparency and makes the rounded outer corners square. Any user-set WebKit renderer variable takes precedence. - Linux uses a frameless window with a custom title bar, resize handles, and rounded outer corners. The rounded corners rely on the transparent window surface above. The inner workspace panels are rounded independently.
- Deleting captures makes those historical image attachments unavailable; the provider receives an explicit missing-image message. Clicking an attachment in the composer or transcript opens a full-window preview; close it with Escape, the backdrop, or the close button.
- macOS builds are unsigned unless you configure signing and notarization.
The local Codex integration follows the official Codex app-server protocol. The separate live Codex test consumes plan usage and is excluded from npm test.
Command Code
Settings → KI-Verbindung → Anbieter → Command Code is the default connection. It talks to the OpenAI-compatible endpoint at https://api.commandcode.ai/provider/v1 and lists models from /models. Chat models use /chat/completions; Claude models, which Command Code serves only through the Anthropic Messages API, use /messages with the same key. Both shapes support streaming, tool calls, and images. A key saved in the app is tried first; when none is stored, Kolora falls back to the key from an existing Command Code CLI login. Both sources need no keychain access. Usage is billed to the Command Code account. Switching providers keeps every provider's model and key, so you can move between all bundled services and a custom API without losing settings; the composer picker selects which stored model is active.
Web search
The agent has a web_search tool that returns ranked titles, URLs, and snippets from the live web. It tries SearXNG first, then DuckDuckGo Lite, then Firecrawl's public /v2/search endpoint. Everything works without an API key or account; FIRECRAWL_API_KEY only raises Firecrawl's limit. Set Einstellungen → Verhalten → SearXNG URL to use a different instance; the default is https://search.redforged.eu, which must allow JSON at <base>/search?format=json.
web_fetch reads a full page for URLs that matter. It follows at most five redirects, checks every hop for private hosts, requires a successful HTTP status, and converts HTML to readable text. A 403, 404, or Cloudflare challenge is reported as a tool error, not as a successful page. The tools are read-only, allowed in plan mode, and never require a paid search subscription.
Simple questions
Short informational requests — translations, definitions, arithmetic, greetings, and small factual questions — are answered directly by the configured model. They do not create a Goal, contract, plan, evidence ledger, critic panel, or report. Only web_search and web_fetch are available, and only when the answer needs a live fact. If those tools keep failing (blocked network, Cloudflare, VPN-hostile search), the model gets one final no-tools round and must state the actual limitation instead of the harness stopping with a generic error. Work requests, code or file references, attachments, tool history, existing goals, plan mode, and longer prompts still use the quality runner.
Prefix caching and the cache indicator
DeepSeek caches request prefixes on disk automatically: a request hits when its token prefix exactly matches a previously persisted cache unit (64-token storage units; caches expire after hours or days). Kolora maximizes the reusable prefix by keeping the system prompt and the tool schema frozen for the run. Per-turn state — plan, verification, blockers, evidence index, current time, and capabilities — is appended as a hidden trailing user message instead of being rewritten into the system prompt. The transcript history itself is append-only until compaction.
The usage parser reads DeepSeek's prompt_cache_hit_tokens / prompt_cache_miss_tokens, OpenAI-style prompt_tokens_details.cached_tokens, and Anthropic-style cache_read_input_tokens. The rate is shown as a Cache % chip in the chat header, as Prefix-Cache in the status panel, and in the context view with hit and total prompt tokens.
A 99% rate is workload-dependent, not a guarantee: long stable instructions, long reference material, and small per-turn deltas hit more often; compaction, model switches, AGENTS/skill edits, and short prompts reduce the rate.
Adapta (developer preview)
Adapta is a virtual provider called Kolora with exactly one selectable model, adapta. It is disabled by default and has no key of its own: every route uses the Command Code key and endpoint.
Turn it on with Einstellungen → Verhalten → Entwicklermodus, then open the new Entwickler tab and check Adapta entsperren. The provider then appears in the composer's model picker as Kolora / adapta.
Each request is routed deterministically:
- Under 100k estimated tokens, without tool traffic or an action verb →
deepseek/deepseek-v4.1-flash-fast(cheap and fast) - Under 100k tokens with real work (tool calls, action verbs, code paths, a long prompt) →
claude-haiku-5-5 - 100k estimated tokens or more →
deepseek/deepseek-v4.1-flash
The three model IDs are editable in the Entwickler tab and must exist on Command Code. The run panel shows the chosen lane and model. Every request tells the model the exact id that serves it, so asking for the model string returns the lane model (for example reflection/beam:free or claude-haiku-5-5) instead of a guess; the prompt also forbids inventing a different model, creator, or training story. Adapta sends text only (no image attachments), and contract extraction always uses the hard lane. Command Code does not currently list a Nemotron 3.5 Lightning model, so the fast lane defaults to the cheap DeepSeek fast model instead.
Other API providers
The Anbieter dropdown also connects directly to these endpoints. Each key is stored under its own account in the 0600 keys.json and is never written to settings.json or sent to the renderer. Claude uses the Anthropic Messages API with x-api-key and anthropic-version; the other providers use the OpenAI-compatible /chat/completions shape.
| Provider | Endpoint |
|---|---|
| DeepSeek | https://api.deepseek.com/v1 |
| OpenRouter | https://openrouter.ai/api/v1 |
| Claude (Anthropic) | https://api.anthropic.com/v1 |
| Google AI | https://generativelanguage.googleapis.com/v1beta/openai |
| Cerebras | https://api.cerebras.ai/v1 |
| Mistral | https://api.mistral.ai/v1 |
| Venice | https://api.venice.ai/api/v1 |
| OpenCode Zen | https://opencode.ai/zen/v1 |
The composer model picker queries /models for every connected provider, so the first save of a provider key is enough to choose a model from that service.
Inception Labs
Settings → Inception connects directly to https://api.inceptionlabs.ai/v1 using a separate Inception API key stored in the 0600 key file. The default chat model is mercury-3; you can pick another model from the live chat-model catalog in the composer after saving your key. Generic API settings and the ChatGPT/Codex login remain available when switching providers. Inception usage is billed to the Inception account, independently of Codex plan usage.
Mercury chat models support text, streaming, and tool calling. Kolora does not send image attachments in Inception mode; existing screenshot messages become explanatory text. See the official Inception documentation.