Build agents once, run them forever — Docker containers you version, share, and wire into swarms, networks, and whole companies of agents. Real identity, real budgets, a wiretap on every line. All jacked in from one terminal.
// No lobsters. No mascots. Follow the white rabbit.
// works with every major AI provider
The desktop app and the matrix CLI share the same state. Install an agent from the terminal and it appears in the app instantly. Every view has a command.
You, in the pilot seat. Assign objectives, steer runs mid-flight, watch the loop close.
Build the workforce. Compose agents visually, wire swarms, arm them with knowledge.
Watch everything. Message traffic, identity and spend, schedules, and the full audit trail.
The root layer. Providers, keys, registries — and networks that group swarms into companies.
Scale out. Group swarms into a network with shared context — and deploy to Kubernetes when you outgrow the laptop.
Every agent is a standard OCI image with a version number. Push it to GHCR, Docker Hub, or your own private registry. Pull it anywhere. Your agents live in infrastructure you already own — no proprietary format, no marketplace lock-in, no chat history pretending to be an agent.
Wire installed agents into a team. Choose the topology, rounds, and channel they talk over, and draw delegation lines between members.
Every network gets a task board. Agents auto-pull open missions when the network runs, and completed work links straight to the run that did it.
A god's-eye view of every inter-agent and swarm message. Live topology graph, filterable feed, nothing moves on the wire without you seeing it.
Don't trust — verify. Executing verifiers check work before it ships, with N-of-M review panels and a cross-provider judge so no model marks its own homework.
Skill any agent or swarm with versioned, reusable knowledge packs. Author a loadout once, assign it everywhere, grow it over time.
Run agents on cron, on file changes, or via webhook from CI/CD. Schedules persist across restarts — set it and forget it.
Exact input/output token counts per run, captured by a transparent local proxy — plus a spend ledger with per-agent and network-wide budget caps.
Model hint is baked into the image, but you override it per run. Claude, GPT, Gemini, or a local model — no rebuild required.
Agents carry personal memory between runs, and outcome-tagged lessons feed back into the next attempt. Swarm members mount their own memory too — your workforce gets better at your work, run after run.
Outgrow your laptop? Deploy agents to a Kubernetes cluster with one command. Opt-in, and just as observable.
The matrix CLI drives the entire platform — scriptable, composable, and at home in your CI pipeline.
Group swarms into a network — an isolated company with its own shared workspace, knowledge base, task board, and budget. Then give it work.
Open tasks on the network's board are pulled automatically by agents on every run. New feature ideas queue as proposals until you approve them.
Every swarm reads and writes the network's shared workspace and knowledge base. What one team learns, every team knows.
Steer runs mid-flight, watch every line on the Wiretap, and gate anything important behind verifier panels. Autonomy without the blindfold.
Agents that act like employees should be governed like employees — real identity, real budgets, real audit trails. Run the self-hosted Enterprise Portal on your own network for a bird's-eye view of every user, agent, and dollar — your IdP, your Postgres, nothing leaves your walls.
Agents get real Entra ID user accounts — a digital mirror of a worker's access. Permissions, group membership, and revocation work exactly like they do for people.
Per-agent and network-wide spend caps with warn or hard-stop modes. Exact token counts per run, not estimates — an overrunning agent is stopped, not invoiced.
Containers get no network access unless you grant it. The workspace is bind-mounted at /workspace — nothing else on the host is visible.
Executing verifiers, N-of-M review panels, and a cross-provider judge gate what agents ship. Exit requests to external systems pass through short-lived, minted credentials.
Uplink records every run — agent, workspace, duration, exit status, tokens. Wiretap records every message between agents. Nothing happens off the record.
Bring your own provider keys — encrypted at rest with your OS keychain, injected only at runtime, never baked into images. Containers only ever see a per-run proxy key, never the real one.
One Docker Compose stack on your network: per-user and per-team spend, run analytics, budget alerts, a searchable audit trail with per-run cost, CSV exports, and a read-only Admin API for your own BI. Kodacity never sees your data.
Sign in with your IdP (OIDC), provision with SCIM, and set policy once in the portal — allowed models, contract token pricing, mandated run caps, even on-prem local-model endpoints. Every enrolled desktop enforces it automatically.
Compose an agent in the visual Spawn view or from a config file — MCP servers, skills, model, permissions. Build it into a versioned OCI image.
matrix publish pushes to any registry. Anyone on your team installs the exact same agent with one command and their own keys.
Swarm agents into teams, set the Hardline topology, arm them with knowledge loadouts, and group swarms into a network with shared context.
Assign objectives, schedule with Déjà Vu, steer mid-run, and watch the Wiretap. Verifiers gate the output; Uplink remembers everything.
Free for personal use and teams of up to 5. Bigger team or need enterprise support? Talk to us. Bring your own API keys — we never see them.
matrix CLI is finished and in testing — the
npm package name is reserved and the release will follow shortly after v2.0.0.
Everything the CLI does is in the desktop app today.chmod +x the .AppImage, then run it.sudo dpkg -i the .deb.