CLAI

A desktop app for building, running, and supervising small teams of AI agents.

What it is

CLAI organizes work into workspaces. A workspace is an ongoing conversation with a main agent — a configurable LLM that owns the workspace's provider, tools, skills, and permissions. The main agent can:

• Chat with you in a surface that stays front and center
• Use tools through attached MCP servers and a local filesystem/shell sandbox
• Delegate to helper agents in the same workspace, each with their own skills, tools, and execution policy
• Persist context — memories and artifacts it writes are inspectable from the workspace header
• Run on a schedule — periodic workspaces fire on their interval

The Fleet view supervises everything: scheduled workspaces float to the top, anything needing attention (failed or blocked tasks, input prompts) is flagged, and selecting a card slides in a live chat preview.

Features

• Workspace-local agent teams — Add helpers (e.g. a Code Reviewer or SoW Tracker) with their own prompts, skills, MCP servers, providers, and execution policy. The main agent calls them as tools, and you can read their full transcripts.
• Multiple providers — API connections (OpenAI-compatible or Anthropic-compatible) and local CLI agents such as Claude Code and OpenAI Codex. Each agent picks its own.
• MCP-native tools — Configure MCP servers once in Settings, then attach them per workspace or per agent. HTTP and stdio transports.
• Local execution sandbox — Per-agent filesystem grants and three shell modes: Off, Restricted (only allowed command prefixes — kubectl get permits kubectl get pods but not kubectl delete), and Full.
• Bundled skills + templates — Reusable skills (iterative review, delegation, second opinion, SoW workflow) and agent templates (code-reviewer, sow-tracker) ready to drop in.
• Inspectable tasks — Delegated work streams a live transcript: the helper agent's full conversation, tool calls, and verdict.
• Memory & artifacts — Agents persist findings to the workspace directory; the drawer surfaces both, with read-only previews (rendered markdown, pretty JSON, multi-file HTML).
• Run notices — A run that hits a policy denial finishes in an amber "warnings" state and surfaces in the Fleet, instead of failing silently.

Local execution is not sandboxed. Shell commands run as your OS user with full privileges. The allow/block lists control which commands an agent can run, not what those commands can access — if you allow cat, the agent can read any file you can. Path grants apply only to the built-in fs_read/fs_write tools, not to shell commands. Prefer Restricted mode with a minimal allow list, and review run notices for anything unexpected.

Install

Download the latest build for your platform from the Releases page:

Platform	Download
Windows	.msi / .exe
macOS	.dmg
Linux	.deb, .rpm, or .flatpak

Getting started

1. Add a provider — In Settings, connect an API provider or point CLAI at a local CLI agent. Claude Code is auto-detected and pre-wired into new workspaces.
2. Add MCP servers (optional) — Register local or remote MCP servers for external tools.
3. Create a workspace — From the Fleet view. Open its settings (gear icon in the header) to attach a provider, MCP servers, and skills.
4. Chat with the main agent.
5. Add helper agents (optional) — From the Agents drawer, pick a template or build one from scratch; the main agent can then delegate to it.
6. Make it periodic (optional) — Toggle Schedule to run the main agent on an interval.

Providers

• API connections — Add an OpenAI-compatible or Anthropic-compatible provider with an API key and optional custom base URL. Works with OpenAI, Anthropic, together.ai, Groq, and local endpoints (vLLM, llama.cpp, Ollama).
• CLI agents — Drive a locally installed coding CLI directly, such as Claude Code or OpenAI Codex. CLAI exposes its tools to them over MCP and streams their output like any other run.

Each agent chooses its own provider, so you can mix — for example a Claude Code main agent with an OpenAI-compatible reviewer.

Development

git clone https://github.com/juacker/clai.git
cd clai
npm install
make dev            # run the desktop app in development

Before pushing:

npm run lint && npm run format:check && npm run build
cargo fmt --manifest-path src-tauri/Cargo.toml --check
cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets -- -D warnings
cargo test --manifest-path src-tauri/Cargo.toml

Architecture

• Frontend — React + Tauri; a chat-first workspace with a drawer for agents / tasks / memories / artifacts and slide-out transcript and file panels.
• Runtime — Each workspace owns one or more agent rows and a persistent session. Built-in tools (filesystem, inter-agent calls, task management) plus MCP tools, gated by each agent's policy.
• Scheduler — Periodic workspaces run from the agent runner, emitting the same streaming events as interactive chat.
• Skills + templates — Bundled via include_dir! and re-materialized under the user's data directory on startup; personal skill sources sit alongside.

License

MIT