Klaus
International site Sign in
Contact us Download Klaus

What is Klaus

Klaus is an AI workbench for real work: how it works, what each area of the interface is responsible for, and where to find every capability.

Klaus is an AI agent application built on its own in-house engine, available as the desktop app Klaus (macOS, Windows), the command line Klaus Cli, and Klaus iOS for remotely controlling the desktop app. It does more than answer questions: it reads your project context, plans, searches, modifies files, runs commands, and verifies results, keeping confirmation points on the actions that matter.

It is not a chat box. Tasks happen inside your real project directories; local files, command output, web content, and tool results are all inputs to the work, and the reasoning, artifacts, and status of every step can be reviewed afterwards.

How Klaus works

A complete task usually goes like this:

  1. Pick a working directory. Create a project for a directory, and the sessions inside that project revolve around real files and commands; use a plain conversation for one-off questions. The working directory decides where its file operations and commands happen by default.
  2. State the outcome you want, not a single step for it to perform. Use @ to reference files, or paste screenshots and logs directly.
  3. Enter Plan mode when you want discussion first. Select "Plan" in the composer's + menu (or /plan in the quick commands submenu). Investigate, answer key questions, and review the complete proposal. Edit the full text in the right panel, then choose "Yes, implement this plan" to start execution under the existing permission preset. See Plan mode.
  4. During execution it calls tools one at a time. Actions like writing files and running commands are either allowed through directly or surfaced as a card asking you, according to the permission rules. You can add a message at any point to steer it, without waiting for it to stop.
  5. Review and wrap up. Inspect changes file by file in the changes view and commit the whole repository once everything checks out. For work that spans many turns, attach a goal so it self-audits at the end of each turn whether the end state actually holds.

Main interface areas

Area Purpose
Sidebar navigation New conversations, plus extensions (collapsible groups: connectors / skills / plugins / quick commands / agents), channels, scheduled tasks, memory, and friends; usage and settings at the bottom
Session list Four sections — pinned / channels / projects / recent — each collapsible; projects are grouped by working directory, and sessions waiting for your input come first
Conversation area and composer Where the task lives. Above the composer you can switch model, effort level, and permission profile, dictate, and reference files / chats / tabs / friends; messages sent while a task is running are queued by default, and ⌘/Ctrl+Enter steers instead
Overview panel Plans, sub-agents, background processes, artifacts, and references (skills / memory / MCP)
Files panel File tree of the working directory with filtering and renaming; documents and code are edited directly and saved automatically
Changes view Changes by branch, uncommitted, commit, last turn, and other scopes, with repository and base selection; committing happens here too
Terminal panel Live output of the commands Klaus runs
Artifact preview Generated web pages, images, and documents preview in place, with a toggle between source and preview
Mini A small companion floating on the desktop: follow tasks, approve and answer in place, send messages, talk by voice, optionally with a pet
Settings Profile, friends, preferences, keyboard shortcuts, voice input, Mini & Pets, import, archived sessions, configuration, models, web, pre-authorization rules, hooks, dreaming, remote control, system permissions, and about

Capability map

Tasks and sessions

  • Main interface and sessions: how the sidebar is organized, and what renaming, exporting, branching, archiving, and rolling back each actually do.
  • Goals and side tasks: cross-turn goals with self-auditing, plus side tasks that branch off the main line.
  • Plan mode: investigate, discuss, and review a complete proposal before explicitly starting implementation.
  • Parallel worktrees: changes land on independent branches without interfering with each other; merging is up to you on the git side.

Permissions and boundaries

Changes and verification

Proactive follow-up

  • Scheduled tasks: run unattended on a cron schedule, with results deliverable to IM.
  • Channels: bring in messages from Feishu, DingTalk, WeChat, WeChat Work, QQ, Telegram, Discord, and WhatsApp.

Memory and models

  • Memory and dreaming: automatic recording each turn, plus "dreaming" that organizes recent sessions into a digest — both switches are off by default.
  • Models: your own subscriptions (Claude Code / Codex / Qoder / QwenWork / QoderWork / WorkBuddy / Kimi), plans (Bailian / MiniMax / Zhipu / Ark), and custom API keys, plus Ultra parallel collaboration, Claude multi-account rotation, and the quota view.
  • Web search: Bing browser search by default; you can switch to model-native search, search bundled with a model subscription, or Brave.
  • Image, video, and audio generation, answer styles: the generation tools are always present, but whether they can be used is decided at each call; switching styles only changes how answers are expressed.

Output and collaboration

  • Session artifacts: where to find generated files, pages and charts rendered in place, interactive components, and running previews.
  • Cross-session collaboration and cross-device communication: one chat can read from, wait on, and delegate work to another, and multiple computers on the same account can reach each other.
  • Friends: add friends and send them tasks, which run on their own computer after they approve the scope.
  • Mini and Pets: follow tasks, handle approvals, and talk by voice without opening the main window.

Extensions

  • Skills, plugins: teach it a specific task, or install a whole bundle of capabilities at once.
  • MCP and connectors: built-in capabilities, system connectors, and custom MCP servers.
  • Browser control, Computer Use: let it operate web pages and desktop apps that have no API.
  • Hooks: run shell commands on 17 lifecycle events.

Configuration and operation

Internals

Read this group when you want to understand a limit or troubleshoot: process architecture, how a turn runs, context and auto-compaction, how memory grows, how extensions get loaded, where the data lives.

The three clients

Klaus and Klaus Cli are two local front ends of the same product engine: configuration, sessions, and memory are shared. Klaus iOS does not run the engine on the phone; it connects through the same account to a desktop client that allows remote control.

  • Klaus: the full workbench. Project sessions, the changes view, the Overview panel, message channels, scheduled tasks, and the skill marketplace in one window. Supports macOS (Apple Silicon) and Windows x64.
  • Klaus Cli: the terminal-native form. Interactive sessions, one-shot execution (klaus exec), code review (klaus review), and direct MCP calls (klaus mcp call), all scriptable and CI-friendly.
  • Klaus iOS: the remote client on iPhone. View desktop devices, projects, and sessions, send messages and attachments, handle confirmations, and manage devices; see the Klaus iOS overview.

The desktop app and the CLI read the same files: user-level configuration, skills, hooks, and MCP servers live under ~/.klaus, and project-level ones under <project directory>/.klaus. A project you have opened in Klaus can be continued in Klaus Cli by pointing -C at the same directory. iOS sees the devices, projects, and sessions synced out by the desktop client you selected; it never reads these local directories directly.

Account and data

  • One account: the web portal, Klaus, Klaus iOS, and Klaus Cli all sign in with the same account. An account is not required for using models: model sources use your own Claude, ChatGPT/Codex, Qoder, and other subscriptions or API keys; the account is for features such as friends, cross-device work, and phone pairing. See account and sign-in.
  • Work stays local: tasks run around the local project directory you choose; file access and command execution are governed by confirmation and sandbox policies, and credentials are stored only on this machine and hidden from the model.
  • Explainable: conversations retain task records, complete proposals, artifacts, and references. Plans and goals have right-panel editors; execution progress appears in the conversation and Overview.

Next steps