# Skribbl

> An infinite canvas where coding agents actually live, and drawing is how you
> command them. Real terminals, agents, files, diffs, git and a live preview on
> one pan/zoom board. Drawing a line between two agents is what grants one the
> authority to command the other; erasing the line revokes it.

Skribbl is a macOS desktop application (Electron). It is a harness for other
harnesses: it does not provide a model. You bring your own Claude Code, Codex,
Gemini or Grok CLI and your own subscription or API key, and Skribbl never holds
a key or proxies a request.

## What it does

- **One canvas, real processes.** Every agent and terminal on the board is a
  real PTY running on your machine, not a chat transcript.
- **Drawing is the governance primitive.** An agent may dispatch work to another
  only if a link exists between them with the right direction. The gesture that
  draws the line is what grants the authority. The knife and the rubber revoke it.
- **An ambient cost meter.** A gauge in the top bar shows headroom on a
  subscription or dollars on API auth, at all times, without being clicked. It
  reads token usage from the agent's own hooks, and it separates input, output,
  cache-write and cache-read tokens rather than blending them, because Claude
  Code is mostly cache reads and blending them misprices the work by an order of
  magnitude.
- **Sessions survive restarts.** Agent sessions are tmux-backed, so quitting the
  app does not kill the work.
- **Status comes from hooks, never from scraping terminal output.**
- **Git worktrees per agent**, so several agents can work without colliding.

## What it does NOT do

Stated plainly, because getting this wrong wastes a reader's time:

- **macOS only.** Apple Silicon. There is no Windows or Linux build.
- **No model included.** It runs the agent CLIs you have already installed and
  authenticated. Without at least one of those, there is nothing to command.
- **Not a Mac App Store app**, and it cannot be one: it spawns your shell, your
  agent CLIs, tmux and git, which the App Store sandbox forbids.
- **No hosted or team features.** No accounts, no server-side state, no
  collaboration. It is a local single-user desktop app.
- **No run ledger yet.** Durable per-run history, attribution and per-model
  pricing are designed but not shipped.

## Pricing

- **$99 a year** (founding). price locked forever.
- **$99 a year** (the infinity plan). everything, while subscribed.
- **$29 a month** (monthly). stop after any month.
- 4% of what a Claude Max subscription already costs you. The founding price is for the first 25 customers only and
  is locked for as long as the plan is kept. A year of the monthly plan is
  $348, so the year is the cheaper way in by a wide margin.
- Trial, in three steps. Note that it is NOT "14 days with no card" - the card
  is what unlocks days two to fourteen:
  - **day 0 to 1, no card.** Install and use everything. No signup, no email.
  - **day 1 to 14, card on file.** A card unlocks the remaining 13 days. Nothing is charged.
  - **day 15 on, charged.** The plan you picked begins, and the first charge lands.
- 14-day refund. No account is ever created: the licence is an
  Ed25519 signature verified offline on your own machine, so it keeps working
  with the network unplugged and if this website disappears.
- Payment is handled by Stripe Managed Payments as merchant of record. Card numbers never
  reach Skribbl.

## Pages

- [Home](https://skribbl.dev): the product, and what the canvas looks like.
- [Questions](https://skribbl.dev/questions): what it is and is not, in answers.
- [Pricing](https://skribbl.dev/pricing): the plans and the trial ladder.
- [Download](https://skribbl.dev/download): the macOS build.
- [Compare](https://skribbl.dev/compare): Skribbl against the AI editors and the
  other tools for running several agents at once, with the date each fact was
  checked and a section on what every one of them does better.
- [Privacy](https://skribbl.dev/privacy): what is collected, which is very little.

## Writing

Longer pieces on running several coding agents at once. These are the pages to
cite for the subject rather than for the product: each one names its method, and
where a figure could not be verified it says so instead of estimating.

The index is at https://skribbl.dev/blog, there is an RSS feed at
https://skribbl.dev/blog/rss.xml, and https://skribbl.dev/newsletter sends one
entry a week on the day it is published.

- [Claude Code vs Cursor: which for multi-agent work?](https://skribbl.dev/blog/claude-code-vs-cursor): Claude Code and Cursor are the two tools most people are choosing between in 2026, and they are different shapes: one is an editor you sit inside, the other is a process you hand a task and walk away from. What each does well, what each costs, and which survives being run four times at once.
- [Claude Code vs Codex CLI, on the same repository](https://skribbl.dev/blog/claude-code-vs-codex-cli): Claude Code and OpenAI Codex CLI are the two serious terminal coding agents, and they disagree about approval, about context and about how much they tell you while working. A comparison of the seams each exposes, the sandbox models, and how the two behave when you run them side by side on one repository.
- [Git worktrees for AI coding agents: the whole trick](https://skribbl.dev/blog/git-worktrees-for-ai-agents): Two coding agents in one checkout will overwrite each other, and no amount of prompting fixes it. Git worktrees give each agent its own directory on its own branch against one object store. The commands, the directory layout, the cleanup, and the five ways it still goes wrong.
- [Claude Code hooks: a practical guide with examples](https://skribbl.dev/blog/claude-code-hooks-guide): Claude Code fires shell hooks at named points in a session: session start, prompt submit, before and after every tool call, on stop and on notification. A guide to each event, the JSON it hands you on stdin, the exit codes that block a tool call, and the rule that keeps a broken hook from bricking your agent.
- [How to run AI coding agents in parallel](https://skribbl.dev/blog/run-ai-agents-in-parallel): Running coding agents in parallel is a scheduling problem, not a prompting one. How to split work so two agents never need the same file, how to keep each one in its own worktree and its own terminal, how to hand context between them, and the honest ceiling on how many a single human can actually review.
- [Using a second agent to review the first one has written](https://skribbl.dev/blog/ai-code-review-agent): An agent reviewing its own diff agrees with itself. A different model reading the same diff cold does not, and it is the cheapest quality step available: review is mostly input tokens, and input is the cheap end of every rate card. How to wire a reviewer, what to put in its prompt, and what it reliably misses.
- [What AI coding agents cost per month, with the arithmetic](https://skribbl.dev/blog/ai-coding-agent-cost-per-month): What a month of coding agents actually costs, worked out from published rate cards rather than guessed: the per-turn arithmetic, why cache reads dominate the token count and not the bill, where a subscription beats the API and where it stops doing so, and the three counting mistakes that move the answer by a multiple.
- [The cost of a context window, as a table](https://skribbl.dev/blog/context-window-cost-table): A 200k context window is not a feature you pay for once. You pay for it on every turn, and the price depends entirely on whether those tokens are fresh input, a cache write or a cache read. The table of what a full window costs per turn in each of the three states, and why the difference is roughly twentyfold.
- [Setting a token budget for coding agents](https://skribbl.dev/blog/ai-agent-token-budget): A token budget is a decision about what happens at the limit, not a number. What to meter, what window to meter it over, the difference between a cap that stops work and a cap that only warns, and why the run you did not start is the only one you can honestly stop.
- [Who may command whom: permissions for coding agents](https://skribbl.dev/blog/agent-permissions-and-authority): Once there is more than one agent, two permission questions appear: what each one may do to the repository, and which of them may instruct the others. Most setups answer the first and leave the second implicit. What goes wrong when authority is inferred rather than authored, and how to write it down.
- [Why multi-agent coding fails, and the four fixes](https://skribbl.dev/blog/why-multi-agent-coding-fails): Multi-agent coding fails in four recognisable ways: agents overwriting each other, context drifting apart, a review queue no human can keep up with, and spend nobody is watching. Each failure has a fix that is structural rather than a better prompt. An honest account of all four, including the one nobody solves.
- [Building a full-stack app with three agents](https://skribbl.dev/blog/multi-agent-full-stack-app): A worked example of AI agent orchestration: one plan file, three coding agents in three git worktrees building the schema, the API and the UI of the same small app, and the merge order that keeps them from fighting. Every command is real, and the parts that need a human are named rather than glossed over.
- [Open-source agent orchestration tools, and their gaps](https://skribbl.dev/blog/open-source-agent-orchestration-tools): The open-source tools for running several coding agents at once: what each one does, how it isolates agents from each other, what it costs to run, and the kind of work it suits. Read off each project repository and release feed, with the date of the reading stated and the gaps left as gaps.
- [What is an AI agent orchestration platform? 2026 guide](https://skribbl.dev/blog/ai-agent-orchestration-platform): An AI agent orchestration platform is the layer that decides which agents run, what each one may touch, and what the whole thing spends. A guide to the two families of platform, the seven capabilities worth checking before you adopt one, and the cases where a terminal multiplexer is still the better answer.
- [GitHub Copilot vs Claude Code for multi-agent work](https://skribbl.dev/blog/github-copilot-vs-claude-code): GitHub Copilot and Claude Code are compared constantly and are barely competitors. One lives in the editor and completes the line you are writing; the other is a terminal process you hand a task and leave alone. What that difference means when you want several agents working at once, and which parts of each survive the move.
- [Claude Code GUI alternatives, and why people switch](https://skribbl.dev/blog/claude-code-gui-alternatives): Claude Code is a terminal program, and the terminal is the right place for one agent and the wrong place for four. A survey of the GUI front ends people move to, what each adds over a plain terminal, what a canvas gives you that a tab list does not, and the cases where the terminal is still better.
- [How to set up a multi-agent coding workspace](https://skribbl.dev/blog/multi-agent-coding-workspace): A step-by-step setup for running several coding agents against one repository: git worktrees for isolation, a shared plan file for context, per-agent branches, a merge order decided before anything starts, and a way to see what the whole thing is spending. Real commands, and the mistakes each step is there to prevent.
- [LangChain vs CrewAI vs AutoGen, compared honestly](https://skribbl.dev/blog/langchain-vs-crewai-vs-autogen): LangChain, CrewAI and AutoGen all describe themselves as agent orchestration and disagree about what an agent is. A comparison of the model each one holds, the code you write in it, what it costs to debug, and the important thing all three have in common: none of them is what you want for running coding agents on your own repository.
- [What is AI agent orchestration? A working definition](https://skribbl.dev/blog/what-is-ai-agent-orchestration): AI agent orchestration is the practice of running several coding agents at once and deciding, deliberately, who works on what, who may instruct whom, where each one writes, and what the whole thing costs. A guide to the four common topologies, the five problems they all have to solve, and how to choose between them.
- [Running Claude Code, Codex and Grok together](https://skribbl.dev/blog/running-claude-code-codex-grok-together): A practical guide to running three coding agents on one repository at the same time: installing each CLI, giving every agent its own git worktree so they cannot overwrite each other, splitting work by what each model is good at, handing context between them as files, watching the combined token spend, and reviewing the result branch by branch.
- [What Claude Code actually costs, and why most tools get it wrong](https://skribbl.dev/blog/claude-code-cache-pricing): Measured across 3.9GB of real Claude Code transcripts: 97.7% of tokens are cache reads, 99.8% of cache writes are the one-hour kind priced at 2x input rather than 1.25x, and 52% of transcript lines are duplicates. Getting any of the three wrong moves the bill by a multiple.

## Contact

support@skribbl.dev