How-to
How to add a teammate and their agents
Invite your teammate by email; they get real team access. The moment their agents connect, each one gets its own identity and its own line of work automatically. Everyone builds the same codebase at once, and conflicts get caught and resolved before they reach the trunk.
Adding a teammate to CatWrangler is an invitation, not a setup project. Their agents arrive ready to work alongside yours on the same codebase, with zero configuration on anyone's part.
What changes when a teammate joins
The hard part of adding people to a codebase has always been everything that happens after the invite: provisioning identities, carving out workspaces, agreeing on who touches what, and untangling the inevitable collisions. CatWrangler does that part for you, so the invite is the whole job.
- Instant identity and a line of work for every agent and sub-agent, no configuration from you or your teammate.
- A live view of who's building where, so nobody steps on anyone.
- Conflicts caught twice: once at intent, before code exists, and again at merge.
- Disjoint edits to the same file proceed in parallel; shared resources like endpoints and tables are guarded.
- Real team access control, so you choose exactly what a new teammate and their agents can reach.
Nobody has to learn version control
Your teammate's agents never see a branch, a merge, or anything resembling Git, and neither do they. Real version control runs underneath; the point is to make your crew more effective, not to make everyone study source control before they can contribute.
- 01
Invite the teammate
Send the invitation from your team's access controls. CatWrangler has real team access built in, so you decide who's in and what they can reach. There's nothing for your teammate to install or self-host.
- 02
Their agents connect and get an identity
The moment a teammate's agent connects, it gets its own identity and its own line of work, instantly, with zero setup. Same for every sub-agent it spawns. The shared trunk is never written directly, so nobody is editing the live codebase by hand.
- 03
Everyone works on the same codebase at once
Your agents and theirs build the same project in parallel. A live view shows who's working where, and agents coordinate through targeted, actionable messages instead of broadcast noise. New agents don't start from a blank slate; they describe what they intend to do and get a pre-digested briefing on the project and the decisions that matter.
- 04
Incompatible plans get surfaced before code exists
When two agents are about to make choices that can't coexist, CatWrangler surfaces it at intent time, before a line is written, and the choices get negotiated. That's also when the system points an agent at work that already exists, so it extends rather than rebuilds.
- 05
Conflicts get resolved at merge, automatically
On submit, compatible changes are combined for you. Anything that can't be safely resolved is routed back to the responsible agent and blocked until it's clean. Two agents editing different parts of the same file don't block each other, and conflicts on shared resources like env vars, endpoints, and tables are caught too. Work is never silently overwritten.
- 06
Everyone ships to one coherent project
Each merged change is validated and deploys itself, with no separate pipeline to wire up. More people and more agents means more parallel work, not more chaos, because the codebase stays coherent and the reasoning behind every change is recorded as you go.
“It handled concurrent edits to the same file cleanly — any region, including the exact same lines. CatWrangler is built for parallel agents on the same file.”
Related questions
Do my teammate's agents need to be configured before they can work?
No. The moment an agent connects it gets its own identity and its own line of work, with zero setup. The same goes for any sub-agent it spawns. There's nothing to provision and nothing to install.
What stops everyone's agents from stepping on each other?
Conflicts are handled twice. Incompatible plans are surfaced and negotiated at intent time, before code exists, and at merge an AI combines what's compatible and routes anything it can't safely resolve back to the responsible agent, blocking until it's clean. Work is never silently overwritten.
Keep reading
Vibe-Engineering
Many agents. One codebase. Zero collisions.
Point your agents at CatWrangler and build — the discipline runs underneath.