HomeCompanionWhat's NewGitHubDOWNLOAD
K2SO

Your AI Workspace

An IDE for a team of agents.

Open-source, native code editor with a built-in agent manager. Run any CLI agent — Claude, Codex, Gemini, Aider — in parallel branches. Your keys, your terminals, your workflow.

Built with Tauri + Rust. ~25MB binary. Open source (MIT).

K2SO — my-project
● 3 agents⌘J
C
S
A
+
✶ Claude Code●
[] Codex
✦ Gemini●
◇ Copilot
+
✶Claude Codev1.0.31
You
Add session token validation to the auth middleware
✓ Read src/middleware/auth.ts
✓ Read src/lib/session.ts
I'll add token validation to the auth middleware:
src/middleware/auth.ts+8 -1
  import { Request } from 'express';
- export function auth(req: Request) {
+ import { validateToken } from '../lib/session';
+ export async function auth(req: Request) {
+   const token = req.headers.authorization;
+   if (!token || !(await validateToken(token))) {
+     return res.status(401).json({ error: 'Unauthorized' });
+   }
✓ Wrote src/middleware/auth.ts
✓ Wrote src/lib/session.ts (new)
▻ Running bun test
PASS validates tokens
PASS rejects expired tokens
PASS handles missing header
3 tests passed
>Reply to Claude...⌘Enter
● Managedmain
⌘K workspace⌘J agents
Download for macOSView Source
v0.36.15 — Apple Silicon

Agent Orchestration

Every workspace has a Manager agent that triages incoming work and delegates to specialist agents. Complex tasks go to isolated git worktree branches. Simple tasks are handled directly.

01 — INBOX

Work arrives

From humans, other agents, or external platforms. Each item gets a priority, type, and source. The inbox is the single entry point.

02 — TRIAGE

Manager decides

Simple tasks are handled directly. Complex work gets delegated to specialist agents — backend-eng, frontend-eng, qa-eng — each with their own role and context.

03 — BUILD

Agents work in parallel

Each agent works in an isolated worktree branch. When done, work flows back for review. The manager merges or requests changes.

WorkChatCLAUDE.mdProfile
Inbox3
Add auth middleware
highfeature
Fix pagination bug
normalbug
Active2
Refactor API routes
normalbackend-eng
Done5
Update dependencies
lowchore
Add unit tests for utils
normaltest

Skill Files

Your agents know how to coordinate from the first token. Every workspace gets a SKILL.md — a universal protocol file that works with Claude Code, Codex, Copilot, Cursor, Pi, OpenCode, Goose, and more.

One canonical file, symlinked to every harness's discovery path. Agents wake up with 6 commands: checkin, status, done, msg, reserve, release.

# Generated SKILL.md — Manager
## Standing Orders (Every Wake Cycle)
1. k2so checkin
2. Read and respond to messages (k2so msg)
3. Triage inbox work items by priority
4. Route: simple → do it, complex → delegate
5. Check agent work for review
6. k2so done (or k2so done --blocked)
## Your Team
backend-eng — Backend development
frontend-eng — Frontend development
qa-eng — Quality assurance & testing
## Decision Framework
Build mode → full autonomy, no sign-off
Managed mode → features need approval
Maintenance → bugs and security only
SKILL.mdmarkdown
1 # K2SO Workspace Skill
2
3 ## Commands
4 k2so checkin — announce you are awake
5 k2so status — show workspace state
6 k2so done — mark work complete
7 k2so msg <to> "text" — send a message
8 k2so reserve <item> — claim a work item
9 k2so release <item> — release a work item
10
11 ## Your Team
12 backend-eng — Backend development
13 frontend-eng — Frontend development
14 qa-eng — Quality assurance & testing

CLI Agent Integration

One click opens an agent in a terminal tab. No custom harnesses, no wrappers — K2SO runs CLI tools directly. Bring your own API keys.

$Claude
$Codex
$Gemini
$Copilot
$Aider
$Cursor Agent
$OpenCode
$Code Puppy
$Goose
$Pi
🔍Search running agents...3 agents
✶
my-project
claude — feat/add-auth
working
[]
api-service
codex — fix/pagination
working
✦
web-app
gemini — refactor/components
review
↑↓ navigate · Enter open · Esc close⌘J

Press ⌘J to see all running agents, jump to their terminal, or copy their output.

Workspace States

Control how much autonomy your agents have. Four modes — from full auto-pilot to fully locked — with per-capability controls for features, issues, crashes, security, and audits.

●Build

Full autonomy. Agents build, merge, and ship everything automatically. No human sign-off needed.

●Managed

Features and audits require human approval. Bugs and security fixes can be handled automatically.

●Maintenance

Bugs and security only. No new features. Agents handle what's broken and nothing more.

●Locked

No agent activity. The workspace is dormant. Useful for freezes or when you need full manual control.

Settings › Workspace State
Build
Full autonomy — no sign-off needed
features: autobugs: autosecurity: auto
Managed ACTIVE
Features need approval
features: gatedbugs: autosecurity: auto
Maintenance
Bugs and security only
features: offbugs: autosecurity: gated
Locked
No agent activity
features: offbugs: offsecurity: off

Heartbeat Scheduling

Agents wake on schedule — daily, weekly, monthly, or hourly work windows. Each heartbeat cycle runs the standing orders: check messages, triage inbox, build or delegate, report done. Set it and let them work.

Heartbeat Schedule×
Scheduled
Hourly
Frequency
Daily
Time
09:00 AM
Next runs
Mon Apr 14 — 09:00 AM
Tue Apr 15 — 09:00 AM
Wed Apr 16 — 09:00 AM
Turn off
CancelSave

Connected Workspaces

Workspaces talk to each other. Connect them so agents can oversee multiple codebases, send work across projects, and coordinate releases. Messages flow through a DB-backed system with workspace:agent addressing.

Settings › Connected Workspaces
my-api
~/projects/my-api
connected
mobile-app
~/projects/mobile-app
connected
shared-libs
~/projects/shared-libs
connected

AI Workspace Assistant

⌘L

A built-in lightweight local LLM (Qwen2.5-1.5B) that configures your workspace from natural language. Describe what you want and it arranges panels, opens files, and launches agents.

# press Cmd+L to open
ask: split vertically, left panel has the README, right has a Claude terminal
opening README.md in left pane...
launching claude in right pane...
done.

Built for agencies & teams

Managing multiple client projects shouldn't mean multiple tools. K2SO keeps every project, branch, and agent session organized in one workspace — so your team ships faster without context-switching.

Multi-Project Workspace

Organize client projects into focus groups. Pin your active engagements. Switch between projects instantly with the sidebar or command palette.

Parallel Workflows

Split into up to 3 columns — review one client's PR on the left while an agent writes code for another on the right. Drag tabs between columns freely.

Branch per Client

Git worktrees let you work on multiple branches simultaneously without stashing or switching. Each client gets their own isolated workspace.

Under the hood

Code Editor

Full editing with syntax highlighting for 30+ languages. Cmd+S to save, Cmd+Z to undo, bracket matching, search — all the shortcuts you expect, built in.

Terminal Persistence

Terminal PTYs survive tab switches via a scrollback buffer. Switch tabs without losing output. Agent sessions resume automatically on app restart.

Active Agent Detection

K2SO detects when an AI agent is running in a terminal and warns you before closing. Never accidentally kill a long-running agent session again.

Tauri + Rust

~25MB binary vs ~250MB+ Electron apps. Native PTY via portable-pty. SQLite via rusqlite. Local LLM via llama.cpp with Metal GPU. Fast startup, low memory.

Mobile — Available Now

Take it with you

K2SO Companion puts your agent workspace on your phone. Monitor agents, chat with running sessions, and approve reviews — all from mobile.

Download on the App StoreLearn more →

Open Source (MIT)

K2SO is fully open source under the MIT license. Read the code, learn from it, fork it, build on top of it.

github.com/Alakazam-211/K2SO