aqqua speaks ACP, so every harness lands in the same interface. Nothing is metered, resold or routed through us — your prompts go straight to your provider, and your code never leaves your machine.
ClaudeClaude Code
CodexCodex CLI
GrokGrok CLI
opencodeOpenCode
CursorCursor
pipi coding agentSpawn a swarm against a single change and supervise every thread in one place. Below, Claude runs the orchestration and hands one lane to Codex and one to pi — the provider is a setting, not a rewrite.
Agents spawned with the $orchestrate skill, or straight from the aqqua agent spawn CLI.
Every lane pinned to its own provider instance, model and reasoning level — chosen from what that model actually advertises.
An orchestrator keeps its whole agent tree behind one numbered control, so a large delegation never widens the tab strip.
Flows make your workflow native to aqqua: ordered steps, written down once. Each step runs a specific agent — its own prompt, provider and model — hands its artifact to the next, and keeps going while you read something else.
The planning agent opens its own thread on the exact provider and model you pinned to it, and saves its plan as a named artifact.
The next agent starts clean. It reads the plan by name, works the task's own branch and worktree, and never inherits the last step's context.
Mark a step to pause and the task waits with everything written down. Resume once you've read the work — or don't, and it holds.
Same handoff contract, every run. Each task carries its own branch and worktree the whole way, so two tasks never fight over one checkout.
Describe the pipeline. Each step runs in its own thread, in order.
Each card is a real branch and worktree; each conversation is a tab beneath it. Branch, checkout type and highest priority state ride on the card's face, and merged pull requests show their number — the whole swarm readable at a glance.
Submitting during a running turn queues the message instead of interrupting it. aqqua sends them one turn at a time — steer one in early if it can't wait. The queue is durable thread state, so it survives reconnects across web, desktop and mobile.
Follow the branch's commit graph in the app — lanes, merges and tags — and open any commit's full diff beside it. aqqua reads refs already in the repository and never fetches behind your back.
Watch the change request for the branch you have checked out: state, base and head, aggregate CI and every individual check. Merge, arm auto merge, close or reopen from the same panel — and threads settle themselves once the PR lands.
Live rate limit gauges plus a historical ledger — tokens, turns, cache share and estimated cost by model and project. Scanning stays off until you turn it on, and the logs never leave the machine.
Started something in the Claude Code or Codex CLI? Type /resume in a new draft and pick it up here. The thread adopts the provider session and keeps the earlier transcript one click away.
Run many projects from one window and narrow the registry to the ones that matter right now. Projects group their worktree cards and collapse independently.
Reviewing what an agent did shouldn't mean leaving the app that ran it. Commits, diffs, files and the rest of the workspace live beside the thread that produced them.
Stage the work and let the agent write the message from the diff itself — title, body and scope, no placeholder text.
Read every change side by side before it lands, file by file, without leaving the thread that made it.
Browse and edit the repository in place. No second window to check what an agent touched.
Reach the same threads from another machine or the phone app while the agents keep running on your hardware.
Every surface is one chord away, and the bindings are yours to rewrite when they don't match your muscle memory.
macOS, Windows and Linux from the same build. Same app, same threads, whichever machine you sit down at.
There is no hosted tier holding the good parts back. The repository is the product — clone it, change it, ship it under your own name.
Every surface is yours to restyle or rip out. Not a theme API, not a plugin sandbox — the same source we build the release from.
A driver is a settings schema and an icon. Point aqqua at whatever harness you run internally and it lands in the same picker.
Run it in house behind your own signing keys, or hand it out under your name. MIT asks for nothing back.
Still stuck? The repository's issues and the Discord are both open — and so is every line of the answer.
Actually free. The repository is the product — MIT licensed, top to bottom, with no hosted tier holding features back and nothing to upgrade to. Clone it, change it, ship your own build under your own name.
No. aqqua drives the harnesses you already sign in to — Claude Code, Codex CLI, Grok, OpenCode, Cursor and pi — on the plans you already pay for. Nothing is metered, resold or routed through us.
No. Everything runs locally against your own checkouts, and the app talks to the same provider endpoints your CLI already does. Usage scanning stays off until you switch it on, and the logs never leave the machine.
Each card owns a real git branch and a real git worktree on disk. Agents working different cards never share a checkout, so a swarm can run in parallel without three threads fighting over the same working tree.
A flow is the pipeline written down once: ordered steps, each with its own prompt, its own pinned model and its own fresh thread. Steps take parameters and named artifacts from the steps before them, so every card takes the same path instead of whatever you happened to type that morning.
Yes — that is the point of speaking ACP. Spawn agents with the $orchestrate skill or the aqqua agent spawn CLI and give each lane its own provider, model and reasoning level, all against one branch.
macOS on Apple Silicon and Intel, Windows 10 and 11 on x64, and Linux x86_64 as an AppImage — all cut from the same build. There is a mobile app for reaching threads that are running back home.
aqqua is a community fork of t3.codes, kept MIT and shipped as its own builds. Forking is a supported way to use it: adding a provider is a settings schema and an icon, and every surface is yours to restyle or rip out.
One download, no account, no server to point it at. Sign in to the harnesses you already pay for and the workspace is yours.
Checking the latest release…All releases
