Product / the environment
Four surfaces, one loop: a fleet you supervise, a plan you shape, a diff you review, and a timeline you can rewind. Everything else is in service of those.
Live state for every agent: current file, current command, elapsed time, tests green or red. Sorted by what needs you most. Twelve runs stay legible because status is carried by colour and position, not by text you have to read.
A structured plan — steps, files, checks, assumptions. Editable as text, enforceable as policy. An agent that wants to go outside its plan has to come back and ask.
Side-by-side or unified, hunk-level accept, inline revision requests, and the test output that proves it. Review agent work the way you already review human work.
Every prompt, tool call, command and file write in order. Jump to any point, fork from it, and compare the branches. Nothing about a run is a black box.
01 / fleet control
Running many agents is easy. Keeping their work from colliding — and keeping yourself oriented across all of it — is the actual product.
Each run gets a real git worktree on its own branch. No stomping, no half-applied edits in your working copy, no "which agent broke the build".
Send one brief to three agents with different models or approaches, then keep the diff you like best. Exploration becomes cheap.
Runs that need approval float up. Runs that are healthy fade back. The list is a queue of decisions, not a wall of activity.
Type into a running agent to correct course, pin a file it keeps ignoring, or stop it before it burns another ten minutes.
Cap concurrency, token spend and runtime per blueprint. Runaway loops hit a wall you set, not your invoice.
02 / plan, review, rewind
Steps, target files, commands to run, assumptions made explicit. Approve the whole thing, or delete step four and add a constraint. Blueprints can require approval before any write.
File scopes, command allowlists, network policy, change-size limits. Cross a boundary and the run pauses for you instead of pushing through.
Hunk-level accept, single-line revision requests, and a checkpoint on every tool call. Fork from step three, try another approach, diff the two outcomes.
Leave a comment on line 42 and the agent revises that hunk in place — with the plan, the trace and the surrounding code still loaded. You don't rebuild context; it never left.
// line 42 — your comment you: "use the token's plan tier for the ceiling, not a constant — see billing/tiers.ts" // 8 seconds later agent: revised hunk 3/5 · read billing/tiers.ts + const max = tierLimits[token.tier] - const max = 100 re-ran pnpm test · 41 passed
03 / context engine
Most agent failures are context failures. Commanda builds a local, incremental map of your repositories — symbols, call graphs, ownership, test topology, recent history — and hands each agent the slice its task actually needs.
Built on your machine, updated as you commit. No upload step, no nightly sync, no stale snapshot of a repo from last quarter.
An agent editing the billing module gets billing, its tests and its callers — not 400 unrelated files eating its window.
Attach design docs, ADRs, tickets, incident reports and runbooks. Anything you'd hand a new hire on day one.
Decisions and corrections you make once become durable notes future runs inherit. Stop re-explaining the same conventions every Monday.
task add sliding-window rate limits scope derived from plan · 1.8% of repo ✓ src/middleware/** 14 files ✓ src/router/public.ts caller ✓ test/middleware/** tests ✓ docs/adr/0012-limits.md decision ✓ team-memory: "redis keys are prefixed per-env, see infra/" ✗ infra/secrets/** blocked ✗ .env* blocked window 38k / 200k tokens
04 / customization
Every team has rules that never made it into a linter. Commanda gives them somewhere to live — in your repo, in review, under version control.
A single YAML file defines an agent: model, context scope, tool permissions, hooks, policies. Fork the defaults, or write one from scratch in ten lines.
Shell out to your own scripts before or after any tool call — or to gate a plan. Exit non-zero and the run stops. Your existing tooling is the policy engine.
Markdown and scripts an agent loads on demand: release runbooks, house style, "how we do migrations here". Shared across the team, versioned with the code.
Cheap model for triage, strong model for architecture, local weights for anything sensitive. Set it per agent, per step, or by rule.
Rearrange panes, hide what you don't use, rebind everything. Vim and Emacs bindings ship in the box; export your layout as a file.
A typed plugin API for new panes, custom tools and org-specific views — same surface our own built-ins are written against.
05 / integrations
Commanda isn't trying to replace your editor, your tracker or your CI. It connects to them — in most cases with one line of config, and always without a proprietary format in between.
Git, GitHub, GitLab, Bitbucket. Branches, PRs, reviews and checks — created and updated by agents, owned by you.
VS Code, Cursor, JetBrains, Neovim, Zed. Open any run at the exact file and line; keep your setup untouched.
Linear, Jira, GitHub Issues. Turn a ticket into a briefed agent, and push the resulting PR back onto the ticket.
Sentry, Datadog, OpenTelemetry. Hand an agent a stack trace and a trace ID instead of a paraphrase of the bug.
Docker, Kubernetes, Postgres, Redis. Ephemeral environments and database branches for runs that need to actually execute something.
Anthropic, OpenAI, Google, Azure, Bedrock, Ollama, vLLM, or any OpenAI-compatible gateway you host yourself.
Any Model Context Protocol server, local or remote, with per-blueprint permissions and full call logging.
GitHub Actions, GitLab CI, Buildkite. Run the same blueprints headless on every pull request.
06 / security & control
Agents run in containers with explicit filesystem mounts and network policy. Deny-by-default egress, allowlisted commands, and no path out of the worktree unless you grant one.
Index, traces and history stay on your machine. The only data that leaves is what your chosen model provider needs — and with local weights, nothing does.
Secret files are blocked from context by default and redacted from traces. Agents receive references, and the sandbox resolves them at execution time.
Every prompt, tool call, command and diff is recorded and exportable as JSON. Attach the trace to the commit, and answer "why did this change?" months later.
Self-hosted deployment, SSO/SCIM and org-wide policy enforcement are planned for the enterprise track — tell us your requirements and they'll shape the roadmap.
That's the one we want. Early access is free through the beta, and we onboard teams personally.