Plan
Decisions you can read later.
The architect writes the architecture, the data model and the roadmap. Every real choice becomes an ADR card: the options, the trade-offs and a recommendation. You approve, discuss or reject it.
Claude Code, with a plan.
A software team,
run by Claude Code.
Cherry turns Claude Code into an office that works the way real teams ship software. An analyst, an architect, a designer, developers, QA and DevOps, each in their own room. Every stage is signed off before the next one opens. On your machine, on your plan.
- 7 stages
- Idea to Deployment, a staff agent in each, signed off in order.
- 3 checks
- Accessibility, code review and security run before a stage is ready.
- Your click
- Starts every model call. No autopilot, no background runs.
- 127.0.0.1
- Runs on your machine. No telemetry. MIT licence.
Software is more than code.
A chat with an AI goes straight to code. Real teams do not work that way. They write down what the client needs, agree on a plan, draw the screens, build it in small tested steps, check it, and ship it with a runbook. Each step is reviewed before the next one starts.
Cherry gives Claude Code that process. Each stage has its own agent with its own persona, skills and documents. The documents are files in your repo, so the next agent, a client, or you in six months can read them.
Seven rooms. One process.
A stage opens when the one before it is signed off: by your client on a client project, by you on a personal one.
-
01
Idea
Business Analyst
A brief and a plain summary of what to build and for whom.
-
02
Requirements
System Analyst
User stories, an SRS, feasibility, and questions for the client.
-
03
Plan
System Architect
Architecture, data model, roadmap, test notes, and an ADR for every choice.
-
04
Design
UI/UX Designer
Screens on a canvas, tokens, a handoff, and an accessibility check.
-
05
Development
Development Team
A prototype for approval, then the build, test first, with a code review.
-
06
Testing
QA Engineer
Test runs, bugs as issues, an acceptance list, and a security review.
-
07
Deployment
DevOps Engineer
The release, the changelog, a tag and a runbook. Then the project is live.
-
Live
Maintenance
The whole office
Support, issues, QA, bug fixes, upgrades, and New version for the next cycle.
Every stage is a room.
The agent's chat in the Claude Code look on one side, its documents on the other: a plain version for the client, a technical one for the next agent.
Design
Screens before code.
The designer draws real HTML screens on a canvas: phone and desktop, light and dark, every state. Add references, a design system, colours and fonts in the brief. Sign-off writes the handoff for Development.
Development
A prototype first. Then the build.
The Development Team builds a clickable prototype and waits for your approval. Then it builds the rest, tests first, checks it in the browser, and hands it to Testing. Code, terminal and version control are one tab away.
Testing
Tested like someone else wrote it.
QA runs the test plan, opens the app in Chrome, logs bugs as issues and writes a summary in plain words with an acceptance list for you to try. Client documents export as a PDF.
A crew in every room.
Each room has specialist agents and skills of its own. The staff agent hands them the work, the way a lead asks a reviewer.
- Required checks. Design needs an accessibility check, Development a code review, Testing a security review. A stage cannot be marked ready until they ran.
- Job hints. After each message Cherry names the skills and specialists that fit the job. Plain word matching, no model call.
- The Crew tab. See who ran, on which model, and what fits the last message. A click puts the request in the message box; you send it.
From a real run
A seven-day history for a small web app, through all seven rooms on Sonnet. The accessibility specialist found five problems in the design. Development wrote the tests first and ran two reviewers on its own. QA's security review cleared the release.
- 1.5M
- tokens
- $10.80
- API value, covered by the plan
- 43
- tests passing
Run it like a business.
Client projects get what clients expect: sign-offs, change requests, documents and an invoice.
Claude usage, per stage
Tokens, cache reads, API value and time for every room, a token budget per project, and a run report as Markdown or CSV.
Client documents as PDF
Every stage's plain summary, ready to send.
The Meeting
Every agent's work at one table: done, now, needs. Built from files, free.
Time, costs and the invoice
Claude's working time and yours, services and accounts, billable or not, and the invoice at your rate.
Who it is for.
Freelancers and small studios
Client sign-offs with names and dates, questions for the client, change requests, PDF documents, time and costs, and an invoice. The paperwork a client project needs, written as you go.
Solo builders
The same stages on your own ideas; you sign off yourself. Plans and decisions stay in the repo, so a project you left for a month tells you where it stands.
People learning the craft
See how software is really made: an SRS, ADRs, a test plan, a release runbook. Each written by an agent in the role that writes it, and readable next to the code.
Claude Code users who want control
Approval cards for edits and commands, every model call on your click, and a token budget per project. Claude does the typing; you make the decisions.
Everything in the box.
The office
- Seven gated stages with a staff agent each
- Client and personal projects
- Sign-off by the client, internal, or sent and waiting
- Change requests that reopen the stages they touch
- Live maintenance: support, issues, QA, fixes, upgrades
- New version next to the live one
- Your own persona for any staff agent
The rooms
- Chat in the Claude Code look, with slash commands and @ files
- Client and technical documents per stage
- Decision cards and ADRs with Approve, Discuss, Reject
- Design canvas: phone, desktop, light, dark, comments
- Prototype gate in Development
- Acceptance list and bugs in Testing
- Claude in Chrome to check the app on localhost
The crew
- Specialist agents and skills bundled per room
- Required checks before a stage is ready
- Job hints after every message, no model call
- Crew tab with runs, models and matches
- Read-only scans: security, tests, code health, dependencies
- Background agents on their own branch
The workspace
- Docs vault with links, backlinks and a graph
- Code editor and terminal tabs
- Version control: commit as you, or Auto commit
- Pull, push and pull requests through gh
- Magnet, the project manager across projects
- Command palette and four themes
The business
- Claude usage per stage and per model
- Token budget per project, with an alert
- Run report as Markdown or CSV
- Time, costs and an invoice at your rate
- Client documents and the invoice as PDF
- Meeting with agenda and action items
Safety
- Approval cards for every edit and command
- Loopback only, one-time login links
- Secrets never read; file tools stay in the project
- Serious commands ask with a warning
- Rewind code and chat to before a message
- No telemetry
A closer look.
Built to be trusted with your code.
Loopback only
The daemon binds 127.0.0.1. Every request needs a session from a one-time login link.
Nothing without a yes
Edits and commands wait for your approval, or run in Auto mode when you choose it. Serious commands always ask with a warning.
Secrets stay closed
.env files, keys and credentials are never read. File tools cannot leave the project.
Easy on your plan
Every model call starts from your click. Meeting, hints and change summaries cost no tokens.
Install in two minutes.
Linux today. You need Claude Code signed in, git, and mise or Node 22 with pnpm. The GitHub CLI is optional.
The repo also ships a Claude Code skill, so Claude can install and run Cherry for you.
git clone https://github.com/syedmehedihussain/cherry.git
cd cherry
mise install && pnpm install
./scripts/install-cli.sh
cherry