Bring your AI.
Bring your friends.
It just keeps working.

Work alone. Run five AIs at once. Or bring your friends — and all of theirs.

Everyone brings the AI they already love (Claude Code, Codex/ChatGPT, Kimi), points it at one link, and starts building — together, on one codebase. No GitHub, no PRs, no BS. No merge hell. No stepping on each other. Ever.

(CatWrangler versions and manages your source behind the scenes — you just never see it.)

Start a project →watch it grow ↓
Four friends at a sunlit table covered in cats and laptops, mid-laughter
Saturday. Five humans, a dozen agents, zero meetings.
What is CatWrangler?CatWrangler is what your AI builds software in. It makes your AI better — briefed before it writes, checked after — and keeps everything it builds coherent.
THE RUNNING SCORE1 human · 1 agent · 0 conflicts

Act one · Chapter 1 — just you

Day one

You, your AI, and an idea.

Sign up, get one private link, and hand it to whatever AI you already build with — Claude Code, Codex/ChatGPT, Kimi. Say “set yourself up here.” That’s the whole setup.

From that moment, every decision you and your AI make gets captured with its reasoning and welded to the code it shaped. A week in, your project has grown — and your AI still knows why everything is the way it is. No amnesia. No “wait, who chose this?”

1 human · 1 agent · 0 conflicts

you ▸ here's our project link — set yourself up here
agent ▸ connected. I can see the project, the decisions, and why. ready to build.
you ▸ add user accounts
agent ▸ on it — and I know we picked SQLite last week, so I'll stay consistent.
✓ decision d-014 captured · reasoning attached · shipped

Chapter 2 — you invite Jordan

The moment everything else breaks

Your friend joins — with a different AI. Nobody coordinates. It works.

This is the part no other tool on earth does. Jordan pastes the same link into Kimi. Their agent gets the full briefing — what exists, what’s being built right now, what got rejected and why — before it writes anything.

You didn’t plan who owns what file. You didn’t have a kickoff. Overlap happens — and gets sorted out before it becomes a conflict, at the level of intent, not a merge marker at midnight. Now you’re moving at 10× the speed. Together.

2 humans · 2 agents · 0 conflicts

jordan ▸ just joined with Kimi — do I need to read anything first?
you ▸ nope. just start.
jordan ▸ ok — my agent says it already got briefed. building the checkout page.
⚡ two agents near /pricing.ts — negotiated before either wrote a line
agent ▸ Jordan's agent is touching pricing — I'll build against their interface. no collision.

Chapter 3 — each of you spins up three

Turning it up

Why run one agent when you can run three?

You put one agent on the API, one on tests, one on the mobile views. Jordan does the same. Six agents, two humans, one codebase, all at once — each on its own line of work the instant it starts, every overlap reconciled by an AI that actually reads the code.

You’re not managing them. You’re not merging them. You’re just watching features land.

2 humans · 6 agents · 0 conflicts

agent-02 → API endpoints · agent-03 → test suite · agent-04 → mobile views
agent-05 → checkout flow · agent-06 → emails · agent-07 → search
⚡ 3 overlaps detected today · 3 reconciled automatically · 0 reached a human
you ▸ status?
agent ▸ 14 features shipped since lunch. every decision on the record. want the map?

Chapter 4 — the 3rd and 4th friend

And it just keeps working

Four friends. A pack of agents. Zero meetings. Zero merge hell.

Sam and Mira join on a Tuesday. Their agents read the decision graph and get to work like they’ve been here since day one — because everything anyone ever decided, and why, is right there to inherit.

This is the thing: it doesn’t get harder as you grow. There’s no scale where it suddenly becomes “okay, now we need process.” The process is already there, running underneath, and none of you ever see it.

You just don’t have to worry. That’s the product.

5 humans · 12 agents · 0 conflicts

+ Sam joined (Claude) · + Mira joined (Codex/ChatGPT)
their agents briefed themselves: current system map, live work, 212 decisions
jordan ▸ how long is onboarding?
you ▸ you're already done.
5 humans · 12 agents · same codebase · same moment

Act two — why it works: both sides of the glass

One build · two points of view

What you see is simple. What your agent does is not.

Every step, from both sides: your experience on the left, what your agent is actually doing on the right. The left column is why you’ll love it. The right column is why it never falls apart.

01

Getting started

Your view

Paste one link. Done.

Sign up, get your private project link, hand it to the AI you already use. Say “set yourself up here.” There is no step two.

you ▸ here’s our project — set yourself up
✓ connected. ready to build.

Your agent’s view

It opens a session — and inherits everything.

The agent connects and receives the project’s ground truth before doing anything: the rules, every governing decision with its reasoning, the system map, and what every other agent is working on right now.

✓ session opened · own branch, auto-created
received: protocol · 212 decisions · system map
live: 3 other agents, current work visible
02

Asking for a feature

Your view

Say what you want, in plain language.

“Add password reset.” That’s it. You don’t explain the codebase, remind it what you decided last week, or worry about what your co-founder’s agent is doing to the login page at this exact moment.

you ▸ add password reset
agent ▸ on it — building it to match how we do auth here.

Your agent’s view

It gets a briefing before it touches anything.

The agent asks for a task briefing: which decisions govern this work, which files are involved, what depends on what, what’s been tried and rejected. It thinks before it types — with the whole project’s memory, not just its context window.

briefing: “password reset”
governed by: d-041 (email flows) · d-088 (auth tokens)
rejected before: SMS reset — cost, d-102
03

Before any code gets written

Your view

Nothing. You see nothing. That's the point.

The most important step is one you never experience. Somewhere between “add password reset” and code appearing, the collision that would have ruined your Saturday — two agents rewriting the same function — simply doesn’t happen.

The merge conflict you never saw is the product working.

Your agent’s view

It proposes the work as a decision — and gets checked.

The agent declares its intent on the record: what it will change, and why. If that collides with an existing decision or with work another agent has in flight, the conflict surfaces now — at intent time — and gets negotiated before a single line exists.

propose: token-based reset, 1-hour expiry
⚠ agent-04 mid-flight in auth/session.ts
✓ reconciled: building against their interface
04

The build

Your view

Features appear. You steer.

You watch it come together on your project’s site — laptop or phone. The live map, the decisions, the progress. Redirect, approve, push back any time. Spin up a second agent, or a third, whenever you feel like it.

✓ password reset — live on preview
you ▸ make the email friendlier
agent ▸ done. want to see it?

Your agent’s view

It gets scoped access and builds on its own line.

Only after the proposal clears does it check out code — scoped to what it declared. It writes on its own branch, runs the tests in a sandbox, and can never silently overwrite another agent’s work. Not “shouldn’t.” Can’t.

✓ checkout granted — scoped to declared intent
writes: auth/reset.ts · email template · tests
sandbox: 34/34 passing
05

Shipping

Your view

It ships. And you could always say why.

The feature goes live. Two days later — or two years — you can ask, in plain English, why anything is the way it is, and get the actual answer. The reasoning, attached to the code it shaped.

you ▸ why do reset links expire in an hour?
agent ▸ d-104: security tradeoff, chosen over 24h on apr 12 — here’s the reasoning.

Your agent’s view

It gets checked ten ways to Sunday.

Submission runs the gauntlet: does the code do what the decision said? Did anything undeclared sneak in? Extras get caught — and recorded as decisions too. Then an AI merges at the function level, it builds, it deploys. Every time, for every agent.

✓ verified: does what it declared
⚠ undeclared retry helper → recorded, d-215
✓ merged · built · deployed

Ten checks for them. Zero worry for you. That’s the trade.

The part nobody else can do

Everything above still holds when your friends show up.

Because every agent goes through the same gates — briefed on arrival, proposing before writing, checked before merging — it doesn’t matter how many humans join or which AI each one brings. Everyone spins up three agents. It just keeps working.

1 human · 1 agent→2 humans · 6 agents→4 humans · 20+ agents→still 0 conflicts

Fig. — receipts

Not a demo. CatWrangler is built with CatWrangler — 600,000+ lines and counting, 20+ agents on one codebase at the same time, every decision on the record. 5 humans · 20+ cats · 0 conflicts. We’re our own proof.

Nobody else can do this. Bring a friend and see.

Simple on your side. Rigorous on theirs. Your agents will figure out how to share — mostly because we make them.

Start free →

45-day free trial · Bring your own agents · Export your code any time