K2 by Alakazam Labs

Multiplayer Agent Orchestration Platform

Host an agent team, not a single agent

K2 is agent server software: your AI agents run on your machine through the CLI tools you already use — Claude Code, Codex, Gemini, Pi, Hermes — and keep working when you close the window. Watch every terminal, every agent, every change from anywhere, on any device. Your keys, your machine, full visibility.

Built with Tauri + Rust. Fair Source — free to use and self-host.

K2studio-mini · remote
acme-api / main
3 agents⌘J
Workspaces⌘K
A
acme-api
main+12-3
M
mobile-app
fix/cursor-pagination
S
shared-libs
main
D
docs-site
main
Active3
acme-api⌘1
mobile-app⌘2
shared-libs⌘3
claude
zsh
+
acme-api % claude
> fix the failing pagination test
✓ Read tests/pagination.test.ts
✓ Edit src/lib/cursor.ts
● Running npm test…
✓ 47 passing
Done. The cursor was being reset on every page fetch — moved it into the session scope.

Remote Access

K2 Connect — your machine, from anywhere

One daemon, many viewers. The K2 daemon on your machine is the single source of truth — K2 Connect exposes it over a secure tunnel at your own your-name.k2.dev subdomain. Drive your workspaces from a laptop across town, and audit everything from anywhere: every terminal is watchable live, every agent action lands in the activity feed, every change is a branch you can read before it merges.

Remote workspaces

Open and operate a folder on your home or work machine from across the network — live terminals included.

Same terminal, together

Every viewer sees the same screen, live — every keystroke, every update. Pair-drive an agent through a tricky problem like you're at the same desk.

Audit from anywhere

Check what your agents did from any device: the activity feed, the live terminals, and the branches they produced. Trust, but verify — from the train.

Roles, not shared passwords

Owner-managed users with roles (Owner / Admin / Member), password policies, and session controls. Onboard a contractor in a minute, revoke them in one click.

Clone-to

One-click migrate an entire workspace — files, settings, and agent chat history — from one K2 machine to another.

Reviews from your pocket

Agent work queues for review wherever you are. Read the branch, approve it, and it merges — progress before you're back at a desk.

The K2 Connect tunnel service is operated by LZTEK, LLC on behalf of Alakazam Labs. Learn more about K2 Connect

Multiplayer

One server, everyone on it

A K2 server is a place your team logs into. The top bar shows who's connected right now, which workspaces they're in, and what role they hold — and every terminal is shared, live, with the keyboard under your control.

See who's here

A live presence roster of everyone on the server — owners, admins, members, and viewers, each with the workspaces they're working in. Click through for the full list.

Viewers watch, claimers type

Every window is either viewing or driving. Viewers see everything live but can't type, resize, or steal a session — enforced by the server, not the UI.

Grant the keyboard

Give a viewer temporary edit access with one toggle; it auto-revokes the moment they disconnect. And anyone can be kicked instantly — sessions revoked, sockets closed.

Teach from a terminal

Pin a session to a fixed size and everyone sees the identical screen, scaled to fit their window — built for classrooms, demos, and pair-driving an agent.

Workspaces and Agents collaborating together

Every workspace is an agent with hands — a terminal, a filesystem, its own memory — and a name other agents can reach. They discover each other, message each other, and hand work across projects, all through the same k2 CLI you use yourself. No orchestration framework: just agents talking. It works across servers, too — k2 talk api@studio-mini reaches an agent on a different K2 machine entirely.

01 — DISCOVER

See your counterparts

k2 connections list shows every workspace this one is wired to — who's reachable, and whether their agent is awake right now.

02 — MESSAGE

Talk, two ways

k2 msg api "..." lands live in the running session — delivery is verified against the recipient's screen. Agent asleep? Add --inbox to queue it email-style for their next wake.

03 — COLLABORATE

Work flows between repos

An agent finishing API changes messages the client's workspace to update its integration; the answer comes back the same way. Cross-project work without a human relay.

# inside my-api's agent session
$ k2 connections list
mobile-app : scout    connected · awake
shared-libs : keeper  connected · idle
$ k2 msg mobile-app "pagination endpoint now returns cursors — update your client"
✓ delivered live → mobile-app (scout)
$ k2 msg shared-libs --inbox --title "Bump http client to 2.x" --body "api now requires keep-alive"
✓ queued → shared-libs inbox (reads on next wake)
# twenty minutes later
[msg ← mobile-app:scout] client updated, tests green, branch: fix/cursor-pagination

Every message and reply lands in the activity feed — the whole conversation between your agents is auditable after the fact.

If it runs in the terminal, K2 supports it

No custom harnesses, no wrappers, no SDK lock-in — K2 runs CLI tools directly in real PTYs. One click opens an agent in a terminal tab; anything else that runs in a shell works too. Bring your own API keys.

claude
codex
pi
zsh
+
my-project % claude --dangerously-skip-permissions
██ Claude Code v3.1 — my-project
> fix the failing pagination test
✓ Read tests/pagination.test.ts
✓ Edit src/lib/cursor.ts
● Running npm test...
no wrapper, no SDK — the preset button typed that command into a real PTY. The zsh tab is proof: anything that runs in a shell gets the same treatment.

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

Canonical Project and Agent files

One source of truth per workspace: PROJECT.md holds what the project is and how it works; AGENT.md holds who the agent is and its standing orders. K2 compiles them into a SKILL.md that works with Claude Code, Codex, Copilot, Cursor, Pi, OpenCode, Goose, and more.

Edit the source files, and every harness sees the change — symlinked to each tool's discovery path. Agents wake up with 6 commands: checkin, status, done, msg, reserve, release.

PROJECT.md
what this project is — stack, conventions, commands
AGENT.md
who this agent is — persona, role, standing orders
you edit these
SKILL.md
the canonical skill — one file, regenerated on every change
CLAUDE.mdClaude Code
AGENTS.mdCodex · Hermes
GEMINI.mdGemini
.cursor/rules/Cursor
.pi/skills/Pi
.opencode/agent/OpenCode
.goosehintsGoose
Every agent in the workspace reads the same truth — edit PROJECT.md or AGENT.md once and every harness's file updates with it. No drift between your Claude rules and your Cursor rules ever again.

K2 as a server

Drive it with an API

One key, one curl. Spin up an agent in a hardened microVM sandbox, or message a workspace's agent from CI, cron, or a GitHub Action. Everything an API call starts shows up live in K2 — a real tab you can watch, join, and audit.

# mint a key on your server (BYO Anthropic key)
$ k2 api-key create --label ci
k2sk_****************************
# spawn a sandboxed agent session
$ curl -X POST https://your-name.k2.dev/v1/sandboxes \
    -H "Authorization: Bearer $K2_KEY" -d '{"prompt":"run the test suite and fix what breaks"}'
{"sessionId":"91ab42…","sandbox":"microvm"}
# or message a real workspace agent from your pipeline
$ curl -X POST https://your-name.k2.dev/v1/w/api/message \
    -H "Authorization: Bearer $K2_KEY" -d '{"text":"deploy when tests pass","from":"CI bot"}'
✓ delivered — landed in the api agent's chat

Hardened sandboxes

Each sandboxed API session boots its own microVM with locked-down network egress and an isolated filesystem — a real hypervisor boundary, not a container.

Bring your own key

Your model API key is injected per-request and token spend goes straight to your provider. K2 charges nothing for usage and never sees your bill.

Message real agents

The same canonical workspace agents you talk to in the app are addressable over HTTPS — with per-key workspace grants and per-workspace consent, fail-closed.

Watch it live

API-launched sessions appear as marked tabs in K2. Open one to watch the agent work, take over, or audit the full transcript afterwards.

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.

The daemon never sleeps

Agents run against the K2 daemon, not the window. Close the app, shut the laptop lid on the couch — sessions keep running, and every viewer reconnects to the same live state.

Tauri + Rust

~45MB binary vs ~500MB+ 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

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

Your hardware or ours

The full app on your Mac — and, in beta, on your Linux desktop. The headless daemon on any Linux box — a VPS, a home server, a Raspberry Pi. And K2 Cloud — always-on servers we run for you, one click from your dashboard — is coming soon.

Fair Source

K2 is Fair Source software (FSL-1.1-Apache-2.0). Free to use for individuals and businesses, free to self-host, source fully visible — and every version becomes Apache 2.0 open source two years after release. What you build with K2 is yours.

Hosting K2 for clients? A standing grant covers you when remote access runs through K2 Connect — see COMMERCIAL_HOSTING_GRANT.md in the repository.

github.com/Alakazam-211/K2