Control teams of AI agents.

Local-first, open source, sandboxed. One team per workspace — each with its own provider, files, tools, and permissions, working in parallel, on a schedule, and reporting to you from one Fleet cockpit.

Local-first Open source Sandboxed

See the whole team at a glance.

Fleet brings live work, recent results, and requests for your attention into one board.

Fleet overview of six fictional workspaces. The top bar reads 2 working, 1 needs you: Northstar app and Dependency audit are working, and Coastline launch is waiting for an answer.
Screens from the CLAI app. The workspaces and conversations are fictional demo data.
Desktop appBuilt for local workspaces on macOS, Windows, and Linux.
Open sourceCLAI Desktop is MIT licensed and developed in the open on GitHub.
Local controlsChoose what each agent can read, write, and run on your machine.
Model choiceRun local models (Ollama, LM Studio, vLLM), API providers, or CLI agents per workspace and agent.

Follow the work. Answer when needed.

Fleet keeps every team’s latest activity together. Open a workspace when you want the whole conversation, its tasks, and its files.

Active collaboration

See handoffs as they happen.

Each card shows who is active and the latest conversation. Select a workspace to continue with its Main agent.

Fleet view with the fictional Northstar app workspace selected: Main hands “Add keyboard navigation to Settings” to Builder, with a prompt for that workspace below.
Attention

Know where you’re needed.

When an agent needs a decision, its question appears on the workspace’s card with answer choices, so you can reply from Fleet.

Fleet view with the fictional Coastline launch workspace selected, showing the agent’s question “Which hero headline should ship?” with two answer choices.
Workspace

Every workspace is a full agent cockpit.

Chat with the Main agent, follow the tasks it hands to helpers, and read their reports. Files the team writes open in the artifacts drawer beside the chat.

The fictional Northstar app workspace: the workspace rail on the left, Main’s chat with delegated task cards and Builder’s finished report, and the artifacts drawer previewing reviews/settings-a11y.md.

CLAI in one minute.

Move between workspaces, answer an agent, review artifacts and a chart, follow a helper’s task, and approve a git push.

58-second tour with no audio; keyboard shortcuts are shown on screen. Recorded in the CLAI app with fictional demo workspaces.

Give every agent its own job.

Each agent has its own instructions, model, skills, tools, and local access. Define it once, then add it to the workspaces that need it.

Agent settings

Its own role, model, and skills.

Instructions set what the agent does and how. Each agent picks its own provider and model, so a Claude Code main agent can hand work to a reviewer on an OpenAI-compatible API.

  • API providers, local models, or CLI agents such as Claude Code, Codex CLI, and OpenCode.
  • Attach only the skills and MCP servers this agent needs.
The Builder agent’s settings: it runs on Claude Code with the opus model, has its own instructions, three skills from the CLAI Skills repository, and a Local access summary. Saving changes it in the Northstar app and Dependency audit workspaces.
Local access

Decide what each agent may touch.

Grant the paths an agent may read or write, choose which hosts it can reach, and set its shell to Off, Ask first, or Don’t ask. On Linux and macOS, its commands run in an OS sandbox.

  • Ask first holds commands on the agent’s ask-first list, such as git push, until you approve.
  • On Linux, the Allowlist network mode limits shell commands to the hosts you allow.
  • The ask-first list catches common accidents; the OS sandbox and your path grants are the boundary.
Builder’s Local access editor: a read-only path grant, shell mode, session bus, and the Allowlist network mode with 104 allowed hosts such as github.com, crates.io, registry.npmjs.org, and pypi.org.
Agent library

Define a teammate once, use it anywhere.

Settings → Agents keeps your reusable agents. Add one to any workspace; when you edit it, every workspace using it picks up the change from its next turn. Each workspace still decides whether the agent is enabled there, the context it works under, and the paths it may touch.

Settings → Agents: the reusable agent library with Analyst, Builder, Code Reviewer, and Copywriter, each listing its skills and how many workspaces it is on, and a Create agent button.

Everything an agent workspace needs.

CLAI brings the practical pieces together: models, MCP tools, skills, permissions, schedules, transcripts, and files.

Local and hosted models

Local (Ollama, LM Studio, vLLM, LiteLLM) and hosted providers — OpenAI-compatible and Anthropic-compatible.

CLI agents

Run Claude Code, Codex CLI, and OpenCode from a workspace and keep their outputs in the Fleet cockpit.

MCP client

Connect MCP servers with static credentials or OAuth, then choose which workspaces and agents can use them.

Scheduled teams

Run a workspace on a schedule — every N minutes, or cron with presets like Hourly and Daily 9am. Preview cron runs before saving.

Skills

Reuse instructions from the default clairun/clai-skills repository, local folders, or Git-backed skill sources and attach them where they help.

Artifacts and transcripts

Keep generated files, task transcripts, and durable memories next to the workspace that produced them.

Set it up once, reuse it often.

Create a workspace for a project or recurring task, give agents the right context, and come back to a clear record of what happened.

Connect providers and tools

Add API providers, local CLI agents, and MCP servers from Settings.

Assemble a team

Attach the right model, tools, skills, files, and helper agents to a workspace.

Run the workspace

Start work immediately, schedule it on a cadence, and review transcripts, memories, and artifacts when it finishes.

Frequently asked questions.

Short answers about what CLAI is, where it runs, and how it handles models, data, and local commands.

What is CLAI?

CLAI is a free, open-source desktop app for controlling teams of AI agents. You create workspaces; each has a main agent you chat with and optional helper agents it can delegate to. Every agent has its own model provider, files, tools, and permissions, and the Fleet view shows what every workspace is doing.

Is CLAI free and open source?

Yes. CLAI Desktop is free and MIT licensed, and it is developed in the open at github.com/clairun/clai.

Which platforms does CLAI run on?

macOS 11 or later (Apple Silicon and Intel), Windows 10 or later (64-bit), and Linux x86_64 as .deb, .rpm, Flatpak, or the AUR package clai-desktop-bin. Android and iOS companions are planned but not available yet.

Which models and providers does CLAI support?

Any OpenAI-compatible or Anthropic-compatible API, including OpenAI, Anthropic, together.ai, Groq, and local endpoints such as Ollama, LM Studio, vLLM, and llama.cpp. CLAI can also drive locally installed CLI agents: Claude Code, OpenAI Codex, and OpenCode. Each agent picks its own provider.

Does CLAI run locally? Where does my data go?

CLAI is a local-first desktop app. Workspaces, memories, and artifacts are stored in workspace directories on your machine. Prompts are sent to the model provider you configure for each agent; with a local model they stay on your machine, unless an agent uses the built-in web search/fetch tools or remote MCP servers, which send their requests to those services.

What is a workspace, and what is the Fleet?

A workspace is an ongoing conversation with a main agent that owns its provider, tools, skills, and permissions, plus any helper agents on its team. The Fleet view supervises all workspaces: scheduled ones float to the top, and failed or blocked tasks and input prompts are flagged.

Can agents run on a schedule?

Yes. Toggle Schedule in a workspace's settings to run its main agent at a fixed interval (1 to 1440 minutes) or on a cron expression, with presets such as Hourly and Daily 9am. Cron schedules are evaluated in the workspace's timezone and preview the next run times. Outputs, transcripts, and artifacts stay attached to the workspace.

How are shell commands sandboxed?

Each agent has filesystem grants and one of three shell modes: Off (no generic local file access), Ask first (commands on the agent's ask-first list, such as git push, wait for your approval; everything else runs), or Don't ask (every command runs without asking). Commands run through bubblewrap on Linux and Seatbelt on macOS. Windows has no sandbox backend: CLAI checks the working directory and the allow/block lists, but the command itself is not contained.

How do I install CLAI on Linux, macOS, or Windows?

Download the installer for your platform from the download page. On Linux you can also use the apt repository (Debian/Ubuntu), the dnf repository (Fedora/RHEL), zypper (openSUSE), or the AUR (Arch). macOS builds are not yet notarized, so if macOS says the app is damaged, run xattr -cr /Applications/clai.app once in Terminal.

Questions, feedback, or integration ideas?

Reach the CLAI team directly for product feedback, MCP integrations, packaging questions, or collaboration.

Prefer the open channel? Ask or share feedback in GitHub Discussions.