Point it at a folder. It reads, plans, edits, runs the tests and opens the pull request on your own machine, with your own keys. Every step is written down, and nothing is committed until you say so.
See it work
A real thread: open a folder, ask for the change, watch it read, edit, run the tests and open the pull request.
What it does
The whole surface: the models, the guardrails, the proof, and the places you can reach it from.
Answers from what it can read. Nothing changes.
Read-only modes never see a write tool. The allowlist lives in Rust, so a mode is a guarantee about what the agent can touch, not a line in a prompt. Try it.
Quaka reads, edits and runs commands on your own disk. macOS, Windows or Linux. Nothing is committed until you ask. You review a diff, not a promise.
OpenAI, Anthropic, Gemini, any OpenAI-compatible endpoint, or a model running on your own machine through Ollama or MLX. Keys never leave your disk. Claude Code and Codex work as brains inside the same threads.
Today Quaka talks to Ollama and MLX over HTTP. Next it drives the model itself: weights loaded once, the KV cache kept warm between turns, the GPU actually saturated. The point is a laptop-sized model you'd use for real work, not just to prove it runs offline.
Writing each step down…
Every run is written down as it happens: each step, what it read, what it changed, what the tests said, what it cost. Open any run afterwards and read it back. If the app is killed mid-task, the thread picks up where it stopped.
Commands are classified before they run, and you can edit one before approving it. Writes stay inside the project; credentials stay unreadable. Every edit is snapshotted first, so any step can be rewound.
Daily cap reached. Paused.
$1.90 left before it stops to ask.
Per-turn tokens and cost are on screen as you go. Set a daily cap and a run pauses to ask instead of quietly spending past it. Local models cost nothing and say so.
A long thread re-sends everything the model has already read, every single turn. Prompt caching and a tighter context layer cut that to the part that actually changed: the same work for a fraction of the tokens, and a faster first word.
Each thread is its own agent, on its own git worktree, so two of them can't overwrite each other. Start a refactor, switch tabs, ask about another repo. Close the window; they keep going from the tray.
The agent drives a real Chromium page you can watch and take over. It takes a screenshot and actually sees it, so it catches the broken layout itself instead of telling you it compiled.
Mention the bot in a channel and the run happens on your machine, with your keys and your repo. Permission prompts come back as buttons in the thread, so nothing runs while you aren't looking.
Discord works today. Slack is next, on the same terms: the run happens on your machine, with your keys, and every approval comes back to the channel before anything is touched.
Sign in once. Clone a repo, pick an issue, and the thread gets its own branch. When it's done, the pull request is opened from inside the thread, from your account, with your name on it.
Early access
We are letting people in a few at a time so every thread gets looked at. Leave an email and you will hear from us once, when it is your turn.
New thread