KuroCode

Free during the beta

Your team decides. The agent does it.

KuroCode is where a project gets analysed, decided and built. Closing the analysis is what authorises the work — the same document your team writes on becomes the plan the agent executes, task by task.

Download for Mac · Apple Silicon

Version 1.2.25

Windows · Installer (x64)Linux · AppImage (x64)Linux · AppImage (ARM)

Signed and notarised by Apple, so it opens with no warning at all.

All three systems, from day one.

Session transcript
invoice-apifeat/json-exportsession · qwen3-coder:30b
  1. ›Here is the plan: a --json flag on export, tests for it, and the old --format flag retired.
  2. Reading the repository. Three tasks, and they do not all need the same model.

  3. Plan · 3 tasks

    1. 1Add the --json flagcoderqwen3-coder:30blocal
    2. 2Tests for both shapescoderqwen3-coder:30blocal
    3. 3Retire --format without breaking callersarchitectclaude-sonnetcloud
  4. codereditsrc/cli/export.ts+18 −4
  5. coderedittest/export.test.ts+26

  6. Two tasks done. The third wants the suite green before it touches the old flag.

    Run this command?

    architectrunpnpm test export

  7. architectrunpnpm test export
  8. 14 passed in 2.3s
  9. Two of the three tasks ran on the model on your own machine. Only the migration went to the cloud one.
  10. Stopped. The command never ran, and no process started.
  11. That is the whole idea: the plan proposes, you decide where it stops.

Try it: the agent is waiting for permission.

plan

The project starts with a decision, not a prompt.

A project holds the idea, the analysis and the plan in one document. Closing the analysis is what authorises the work: the plan it produces is a contract, not a suggestion the agent might reinterpret.

  • One document, not a chat and a ticket

    The idea, what got decided, and the task list that follows from it live together — not scattered across a conversation nobody can reread.

  • Closing the analysis authorises the work

    Nothing runs from an open question. The plan only exists once the analysis it comes from has been closed.

  • It replans when reality disagrees

    If what it finds does not match the plan, it rewrites the rest of the list — and keeps the history of what changed, so you can see what it decided and why.

team

One document, two kinds of author.

A project is written by people and by agents on the same page. Every contribution carries who made it — a teammate, or a profile with its own model — and when. Once the team closes the analysis, that is what the agent executes against.

  • People and agents, same document

    The idea, the analysis and the task list all live in one place, whoever wrote them.

  • Every contribution is signed

    Name, model — when it was an agent — and date, on everything, so you can always see who decided what and when.

  • Delegated work reports back

    A task handed to an agent runs in the background and comes back with what it did, how long it took, which tools it used and what it cost.

cost

The expensive model only where it earns it.

Most of a working day is cheap work: read this file, rename that, write the test that mirrors the one next to it. Paying cloud prices for all of it is the reason the bill looks like that.

  • Routine tasks to the local model

    A coding model on your own hardware costs you electricity. It is good enough for the routine half of a plan, and that half never leaves your desk.

  • Hard tasks to the good one

    The design call, the nasty migration, the bug nobody understands — those go to a cloud model, and only those.

  • The mix is per agent, not per session

    The model belongs to the profile, so one plan can run against three different models without you switching anything mid-way.

Spend per day, per model and per project is in settings, so what a project cost — and what the next one will — is a number you can read, not a claim we make.

permissions

Every tool call waits for you.

The agent reads files, searches the tree, edits, patches, runs shell commands and fetches URLs. What it may do without asking is your call, and you can change it mid-session.

Ask
Every edit and every command stops for approval. The default, and the one to use on a repository you care about.
Auto-edit
File edits go through; shell commands still stop and wait. Good for a long plan you are watching.
Bypass
Nothing stops. For a scratch worktree where the worst case is `git checkout .`.

There is also a plan mode: the agent investigates and writes down what it intends to do, without touching a single file.

privacy

What we know about you, and what we don’t.

KuroCode asks you to sign in with a password or Google. What that account holds is short enough to read in one breath.

What the account holds

  • Your email address
  • Your first name, last name and country
  • An account identifier
  • The day you signed up and the last day you opened the app

Where your code goes

  • To your repository, when you push
  • To the model you choose; if it is local, it never leaves your machine
  • To us, never — our servers only hold your account

Your code and prompts only go to the model endpoint you configure: point it at Ollama on localhost and nothing crosses your network card; add a cloud key and the prompts for tasks routed there go to that provider, like any other client. Beyond that, the app talks to us to check your session is still valid and to see whether there is a new version. Nothing else.

where it sits

This is not another assistant.

Coding agents do the work but nothing survives the prompt. Project trackers manage the work but the ticket only describes it — the work happens somewhere else. What changes here is which of the two you get, and whether you get both.

KuroCode

does it and manages it

What it is
Its own desktop app: the shared analysis, the plan and the agent running it, in the same document.
The unit of work
A project: an analysis the team closes together becomes a plan of tasks.
Who writes it
Your team — with name, model and date on every contribution, human or agent.
Who runs it
The agent, task by task, against the plan the team just closed.
What survives
The whole decision trail: who proposed what, when it closed, what it cost.
Your code
Stays on your machine, routed to whichever model you point it at.

Claude Code · Cursor · Copilot

does it

What it is
A terminal or editor session, inside the tool you already have open.
The unit of work
A prompt. What you asked for lives in the scrollback.
Who writes it
Whoever is typing, one prompt at a time.
Who runs it
The agent — but only for that one session.
What survives
Nothing: close the tab and the reasoning is gone.
Your code
Goes to whichever model that vendor puts behind it.

Jira · Linear · Notion

manages it

What it is
A board or a doc, separate from wherever the work actually happens.
The unit of work
A ticket: a title, a description, a status you update by hand.
Who writes it
Whoever writes the ticket.
Who runs it
Nobody — a person or an agent, elsewhere, does the work it describes.
What survives
The ticket itself, but not the reasoning that closed it.
Your code
Not applicable — no code ever touches these tools.

Read as what each tool is good at, not as a scoreboard. They all move fast; if something here has gone out of date, write and it gets fixed.

models

Bring your own model.

Point KuroCode at whatever you already run. A local endpoint is what makes the cheap half of a plan free; a cloud key is what makes the hard half good.

  • OllamaLocal
  • LM StudioLocal
  • DeepSeekAPI key
  • OpenAI-compatibleAny endpoint
  • AnthropicAPI key
  • OpenAIAPI key
  • Google GeminiAPI key
  • GLM · Z.AIAPI key
  • SubscriptionsNo API key

Plus some sixty more providers in the catalogue, picked by name. If you already pay for one of the big subscriptions, sign in with it and spend no API key: the session is yours. Model and reasoning effort are set per agent and per session, so a throwaway question and a refactor of the build system never have to share a model.

repository

Built for repositories, not for snippets.

Every task runs on a repository on your disk, with the tools you would otherwise be alt-tabbing to.

  • Git and worktrees

    Branch, diff and commit locally. Give a session its own worktree so two tasks never fight over the same files.

  • Editor and diffs

    Read what changed in a real editor view before you accept it.

  • Terminal

    A live shell in the same session, so approved commands and your own commands share one context.

  • Streaming transcript

    Output as it happens — tokens, tool calls, results — not a spinner and then a wall of text.

remote

Pick it up from your phone.

A plan started at your desk can be followed from another device on your own network. The desktop app stays the engine; the phone is only a window.

  • Off by default. You turn the gateway on in settings when you want it.
  • Pairing is a QR code, and each device gets its own token you can revoke on its own.
  • Traffic stays on your network — there is no relay in the middle.

price

Free during the beta.

The whole app, on your machine, at no cost while the beta lasts. No trial clock, no card to enter, nothing switched off after a fortnight.

  • What you pay for the models

    Nothing to us. A local model costs you electricity; a cloud key is billed by that provider, the same as it is today.

  • What it will cost afterwards

    Not settled, and we are not going to invent a figure to fill this space. What is settled: working on your own machine, on your own, is what the free side is for. Working as a team on shared projects is what gets paid for, and it will be priced per person.

  • What coming in early gets you

    Whoever is here during the beta keeps an advantage once there is a price. It will be said out loud before anyone is charged, never after.

faq

Questions

Is this just another Jira?

No. A tracker holds a ticket someone else has to go and execute. Here, closing the analysis is what authorises the work, and the same document is what the agent runs its tasks against — the plan does not just describe the work, it drives it.

Do I still need Claude Code or Cursor?

No — the agent that executes the tasks runs inside the project itself, not as a separate CLI session you copy work into. What those tools do well, doing the work, happens here too; what they do not do, remembering the decision and the trail behind it, is the part KuroCode adds.

What if two of us want to work on the same plan?

One person holds a plan at a time: running it reserves it, and everyone else watches its tasks advance without stepping on it. When you let it go, a summary of what you did and what is left is saved, and whoever picks it up starts from your branch, at the last published commit. The code travels through git; we only move the plan.

Which platforms can I download it for?

All three: macOS, Windows and Linux. macOS requires Apple Silicon (ARM64). Windows uses an x64 installer and Linux ships AppImages for x64 and ARM64. The Mac build is notarised by Apple and the Windows installer is signed with a verified-identity certificate.

Do I need an account, and what does it store?

Yes, an account is required. You sign in with a password or Google. It holds your email address, first name, last name, country, an identifier, the day you signed up and the last day you opened the app. And if you work as a team, the project — the idea, the analysis, the plans, the contributions and any documents you attach — is stored too, because that is what lets several people write on the same thing. Your code and your prompts are not: no usage telemetry either.

Does my code ever leave my machine?

Only to the model endpoint you configure. Point it at Ollama or LM Studio on localhost and nothing crosses your network card. Add a cloud API key and the prompts for the tasks routed there go to that provider, like any other client. And when a plan changes hands, the code travels through your own git branch, not through us.

Which models actually work?

Anything served by Ollama, LM Studio or an OpenAI-compatible endpoint, plus Anthropic and OpenAI directly. Development is validated against a 30B coding model running on a local box.

What will it cost?

Nothing during the beta. After that, the split we are working towards is: on your own machine, on your own, free; shared projects with other people, paid. The number is not decided, and it will be published before anyone is charged.

What happens when the beta ends?

Nothing stops working overnight and nothing gets deleted. You will be told what the pricing is with time to decide, and whoever came in during the beta keeps an advantage over whoever arrives after it.