A workspace for coding with agents

Agents write the code. You stay the author.

Run the coding agents you already use, in the repo you already have. Every line is tagged with the agent that wrote it, so several agents can share one checkout and you can still see, and commit, exactly whose work is whose.

Four coding agents in one Code Carta window, three finishing todos and one writing a test, all in one checkout.

Runs the agents you already use Claude CodeCodexGemini CLICopilot CLI GrokOpenCodeKilo Code

Every line, named

You know who did what

Every change is tagged with the agent that made it and the prompt it was given. Nothing goes into your commit on a guess.

How every line is named →
Code Carta's review showing changes across several files, each one labelled with the agent that made it and the words it was asked.
The editor

You never leave the code

Read what the agents did and make the small fix yourself. Keep your IDE; this sits next to it.

See the editor →
The file tree beside an editor showing a TypeScript file with a change bar in the gutter.
Todos

Your todos hand out the work

Type #bug in a todo and it files itself. Hand it to any agent, from any vendor, and it starts. When it's done, the todo is checked off with its commits attached.

Hand out the work →
The project's todos, grouped under bug, feature, math, perf, ux and test, with four handed to agents.
Parity

How it works

Git stages by hunk, so two agents' edits next to each other become one change. Parity tracks each line instead, keeps track through formatters, moves and renames, and won't guess when it isn't sure.

The editor

See what they did, in the code

Click a file path in an agent's output and the file opens at that line, with change bars in the gutter and full language support. The diff is one key away.

The file tree beside an editor open on vector.ts, with a change bar in the gutter beside the function an agent just wrote.
A function an agent just wrote, opened from a link in its output.
Todos

Hand it to whichever agent you like

Type #bug or #perf in a todo and it files itself. Pick an agent from the menu and it starts. When it's done, the todo is checked off with its commits attached, so your list doubles as the change history.

The row menu on a todo, open on Hand to an agent, listing Claude Code, Codex, Gemini CLI, Grok, GitHub Copilot CLI, OpenCode, Kilo Code, and the four agents already running.
Every vendor on one menu, plus the agents already running.
The phone

Your agents, from your phone

The real terminal of every agent, not a chat summary, over an encrypted link to your own machine. Pair once with a QR code and skip the SSH and VPN setup. See which agent is waiting on you and answer it from anywhere.

App Store coming soon Google Play coming soon

The phone app's agents screen: the machine's CPU, memory and swap, then two projects with their agents, each agent's memory beside it, and a button to add a Claude Code agent to either.
Every agent on the machine, by project.
An agent's conversation on the phone, with a row of terminal keys above the keyboard: plus, arrows, enter, escape, ctrl-c, tab, shift.
One agent, mid-task, with the keys it might need above the keyboard.
Your code

We never see it

Code Carta runs on your machine, and your code stays there.

  • The Free plan only goes online when you refresh or install language servers, plus a daily update check that carries nothing about you. You can turn that off.
  • Paid plans also check a licence token about once a day. No file names, paths or usage.
  • Your agents talk to their vendors with your own credentials. We're not in the middle.
  • The phone link is end-to-end encrypted. Our relay only ever sees ciphertext.

Bug reports include your logs, and they're only sent if you choose to. The full policy is one page.

Free, for as many agents as you run

No account needed, and your code stays on your machine.

The engine

Parity

Parity knows who wrote every line. That's what lets several agents share one checkout without anyone's work ending up in the wrong commit.

Live
A review across several files, every change labelled with the agent that made it.
A real, unedited session in the Excalidraw repo: four agents across ten files, each change tagged with its agent and prompt.
Line by line

Line by line

Git stages by hunk, so two agents' edits next to each other become one change. Parity tracks each line instead.

Run a formatter, move a function, rename a file, or close the agent that wrote it. Every line still knows who wrote it.

Certainty

When it isn't sure, it asks

A wrong guess puts someone else's half-finished work into your commit, and you find out when the build breaks. Asking costs you one decision. So when parity can't prove who wrote a line, it holds that line back and tells you why, before you commit.

Promises

What you can count on

Your commit is your work

Commit from Code Carta and you take your own lines, not everyone else's in the file.

A formatter can't steal a file

Reformatting doesn't move authorship to whoever ran it.

Work outlives its agent

Close an agent mid-task and its uncommitted lines are still there, still named, yours to keep or drop.

You'll know who changed your file

When another agent edits a file you're in, you get its name.

Trust

How we know it holds

Unit tests only catch the mistakes someone already thought of. So parity is also checked continuously against real repositories.

Pricing

Free on your machine. Paid when you go beyond it.

Code Carta isn't in your model calls, so there are no token charges or per-agent seats. You pay for phone access, for teams, and for the controls a company needs.

Plans

Free

$0forever

At work or at home, with no account.

  • As many agents as you run
  • The whole parity engine
  • Review, test observer, todos and editor
  • Language servers installed for you, one click
  • No time limit, no account

Pro

$10per month

For one person.

  • The real terminal of every agent, on your phone
  • See which one is waiting on you, and answer it
  • Pair with a QR code, no SSH or VPN setup
  • End-to-end encrypted access to your machine

Teams

$25per person per month

Choose how many seats at checkout.

  • Everything in Pro, for every seat
  • One todo list for the whole team: hand an item to a colleague, see who has it and who finished it
  • Shared parity across people (coming soon)
  • Invite people by email

Enterprise

from $49 per person per month

Invoiced, on terms that suit you.

  • Everything in Teams
  • Run the team server on your own network
  • Policy from a file: relay, service, remote access
  • Invoicing, and the sign-on and audit an organisation asks for

In early access. Paid plans go on sale at launch. Every download today is the Free plan. Pro has a founding price for the first year after launch, $79 a year, kept for as long as you keep the plan.

Downloads

Where it runs

Every build is on the download page, with its checksum.

Windows x64

Installer or portable

An installer that needs no administrator, or a zip that writes nothing outside its own folder.

Linux x86-64

Tarball and a script

Everything beside the binary. One script adds a desktop entry, per user by default.

macOS

Coming soon

The client already runs there. What remains is signing and notarisation.

iPhone and Android

The companion app

Every agent's real terminal, on your phone. On the App Store and Google Play at launch.

Download

Coming soon.

Free. Every agent, the whole parity engine, no account.

Elsewhere
macOS

Coming soon

The client already runs there. What remains is signing and notarisation.

iPhone and Android

The companion app

Ships with the Pro plan: every agent's real terminal on your phone. Answer the one that is blocked and add a todo from wherever you are.

App Store coming soonGoogle Play coming soon

Docs

What is not obvious.

Seven things you would not find by clicking around. Nothing else needs a page.

Tasks Todos What agents can ask Code intelligence The phone Licensing a computer Where things are

Tasks

Your project's commands, as buttons.

The play chip in the band, named for the task it will run. Its menu lists what the project already defines. Press one and it runs in a pane, like an agent. With nothing to run it says Add a task.

  • Read from the project root: a justfile, package.json scripts, Cargo.toml, and .PHONY targets in a Makefile.
  • A justfile that yields tasks hides the other three, so one command is one button.
  • Cargo offers build, test, check, and run only. Never fmt or clean.
  • Missing just? The chip says "Install just" and links to it.

Your own, and pinning

.code-carta/tasks.toml. Only run is required. Name a discovered id to rename it, pin it, or hide it.

[[task]]
id = "user:deploy"
label = "Deploy"
run = "just site"

[[task]]
id = "just:test"
pinned = true

Pinned tasks get their own button in the band. Pin from the chip's menu; it writes the same stanza for you.

Todos

One line. Type it, hand it off.

  • Add: type in What needs doing? and press Enter. That is the whole form.
  • Group: put #bug or #perf anywhere in the line. The word comes out of the title and becomes the group.
  • Attach: a screenshot from the phone, or Attach… on the row. Drop or paste a file anywhere on the card. The agent gets the path.
  • Hand off: row menu, Hand to an agent, pick one. It is typed into that agent's terminal, not sent. You press Enter there.
  • Order: drag. Drop under a heading to file it there too. Ticking is the only way a row moves to Finished.
  • Afterwards: commits the agent makes hang off the row. A ticked box still answers "what changed".

Lives in .code-carta/todos.json in the project. Every window and the phone read the same file.

What agents can ask

The questions an agent can put to the tree.

Registered with each agent on install. They are why an agent says "parity refused" instead of committing your colleague's work.

  • Who wrote these lines? Including uncommitted work, which git blame cannot see.
  • Did anything change under me? Since its turn began, and by whom.
  • What have I changed? Its own files and lines, nobody else's.
  • Who else is here? Every agent in the project and what each is in the middle of.
  • Commit mine. Its own lines, through an index of its own. Refused, with the reason, when a line cannot be honestly separated.
  • Todos. Add one, describe one, finish the one it was handed.

An agent that was handed a todo has its commits attached to it automatically.

Code intelligence

Off until you turn it on.

  • Settings › Asking › Let agents ask about the code. With it on, agents can ask where a name is defined, everywhere it is used, and what the compiler thinks of a file.
  • The status bar says code intelligence off until then. That is why nothing resolves.
  • Language servers are not bundled. Settings › What this project is written in lists what is installed and offers the rest. The button shows version, size and licence before you press it.
  • Nothing downloads on its own.
The phone

Pair once. Off by default.

  • Settings › Reaching this machine from a phone › Pair a phone. A QR code appears. Scan it in the app.
  • Until you do, nothing listens and nothing is advertised.
  • Outside your network the two connect through our relay, encrypted end to end with the key from the QR. The relay sees ciphertext.
  • Unpair forgets the key. Every phone loses access at once.
  • Keep agents running after the window closes: Settings › Away from this machine.
  • iPhone and Android. Part of Pro.
Licensing a computer

Sign in once per machine.

  1. Settings › Your plan › Sign in. Your browser opens the account page.
  2. Say yes. The desktop shows the plan within seconds and renews it on its own.
  3. No browser on that machine? Paste an unclaimed seat's code into the same place.

A seat is one person on any number of their own computers. Offline, a plan keeps working for thirty days.

Where things are
Project list and tasks.code-carta/ in the project. Commit it or ignore it; both work.
Settingssettings.json in Linux ~/.config/code-carta/, Windows %APPDATA%\code-carta\. Edits apply live. Every key is on the settings page.
LogsLinux ~/.local/state/code-carta/. Windows %LOCALAPPDATA%\code-carta\.
Report a bugHelp › Report a bug. Sends the logs with your words. Kept thirty days.
Crash on startRun once with CARTA_DEBUG=1 and send what it printed.

Support

Help, from the people who wrote it.

Email support@codecarta.com. We answer within two business days, and security reports within one.

Report a bug

The fastest way is in the app

On the desktop, open Help, then Report a bug. On the phone, use Send a screen report. Either one attaches your logs and shows you what's in them before you send. Reports are deleted after thirty days.

By email, include:

  • The version (Help › About) and your platform.
  • What you did, what you expected, and what happened instead.
  • Which agent was running.
  • The log, from ~/.local/state/code-carta/ on Linux or %LOCALAPPDATA%\code-carta\ on Windows.

Crashes on start? Run it once with CARTA_DEBUG=1 set and send what it prints.

Request a feature

Tell us what you were trying to do

Email with Feature in the subject. Describe the moment you reached for something that wasn't there. Every request gets an answer, including whether it's planned.

Security

Found something? Tell us first

Email with Security in the subject and we'll reply within one business day. We won't take action against good-faith research, we'll credit you if you'd like, and we'll tell you when the fix ships. If you catch the app sending anything our privacy policy doesn't list, that's exactly the report we want.

Billing

Plans, seats and charges

Sign in on the account page to see your seats and codes. To cancel, or with a question about a charge, email from the address on the account. Refunds: fourteen days on any payment, no reason needed.

Before you write

Offline is fine

A paid plan keeps working for thirty days without reaching us, then falls back to Free until it can.

Parity refused a commit

It tells you why, by file and by agent. How parity works.

About

I built the tool I needed.

Version control assumes every change belongs to a person who knows which change is theirs. Running several coding agents at once breaks that.

Who built it

Carman Babin

I built Code Carta to solve a problem I had myself. I've always been a Vim and tmux user, and I wanted to take my personal workflows to the next level. I don't like using git workflows all of the time, and I hate it when several agents step on each other and get in each other's way.

So one thing led to another, the rabbit hole got deeper and deeper, and I ended up with Code Carta.

The problem

An agent committed somebody else's work

It staged the files it had touched. Those files also held another agent's half-finished tests. It pushed a branch that didn't build.

Nobody was careless. git add takes whole files, and there's no way to ask for less. Other tools solve this by giving each agent its own copy of the repo and leaving you the merge. We made the unit smaller instead: the line. That's parity.

The fear

Agents write code faster than anyone reads it

The worry isn't that agents write bad code. It's that the code stops being yours: you didn't write it, you didn't watch the tests, and a month later you can't say why it works the way it does. It has a name now.

  • Comprehension debt: "the growing gap between how much code exists in your system and how much of it any human being genuinely understands." Addy Osmani, March 2026.
  • In a controlled study of 52 mostly junior engineers, the group coding with AI scored 50% on a quiz about the code they had just worked on. The group coding by hand scored 67%. Anthropic, January 2026.
  • 84% of developers use or plan to use AI tools; 33% trust what they produce. Stack Overflow developer survey, 2025.

Most tools answer with more autonomy. We keep you in the loop: every line tagged with the agent and prompt behind it, every test run visible as it happens, and every commit linked to the todo it came from.

What we believe

What we believe

Asking beats guessing

Pinning work on the wrong author is the mistake that costs people an afternoon.

Copying the repo should be a choice

Use a separate copy when the work needs one, not just to run two agents on two bugs.

Claims should be checkable

Every number on this site is a measurement, not a projection.

Terms of service

The terms you use Code Carta under.

Code Carta is made and sold by CJB Software LLC. Downloading, installing or paying for it means you agree to these terms. They are written to be read, and they say what the rest of this site says.

Last updated
The software
Money
Limits
The rest

Privacy policy

Nothing leaves your machine unless you send it.

This page lists every way Code Carta or this site can come to hold something about you. It is short because the list is short.

Last updated
The software
Accounts
Your rights

Account

One moment.

Checking whether you are signed in.

Checkout

Code Carta

Your order
Code Carta
Due today

Thank you

You're all set.

Your receipt is on its way from Paddle, our merchant of record. Your account shows the plan within a minute.

Next
  1. Download Code Carta if you have not already.
  2. Open Settings and choose Plan, then Sign in. Your browser asks whether to activate that computer; say yes, and the plan is on it.

Go to your account

Change plan, seats or card from your account page. A question about the charge? Reply to Paddle's receipt, or ask at paddle.net. Refunds follow our refund policy.

Refund policy

Try it free first. Then the rules are simple.

The Free plan is the trial, and it never ends. If you paid and want your money back, here is how.

Last updated
The rules
How