Skip to the waitlist

Private beta · For teams on Claude Code

Build together without stepping on each other.

Burl is multiplayer for AI software development — one workspace where developers, teammates and their AIs can work on the same project together. Every AI change is made in its own copy of the project, and a clash always waits for a person.

We’ll only use your email to contact you about Burl early access. To be taken off the list, email [email protected].

You’re in.

We’ll be in touch about early access.

Tell us about your team

What kind of team are you building with?
What are you using today?

Thanks — that helps.

Your own AI
Each person’s AI runs on their own Claude account, and only when they say yes.
Its own copy
Every AI change is made in a separate copy of the project.
A person decides
A teammate’s change lands when an owner keeps it, and a clash always waits for a person.

We’ll be in touch about early access.

You’re in.

We’ll be in touch about early access.

What it looks like in Burl

  1. Alex asks his AI. It works in its own copy of the project.
  2. Sam asks hers. Two AIs, two copies, at the same time.
  3. Sam’s change comes back. A teammate’s change waits for an owner.
  4. Alex keeps it. Now it’s part of the project.
  5. Alex’s AI changed the same lines. Burl holds it back as a clash.
  6. Nothing settles by itself. Alex asks his own AI to combine both.
  7. Alex owns the project, so his clean change lands under the default rule. Both changes are in, and Sam has her AI on the next task.

Recreated from Burl’s screens. The names are made up. Alex owns this project; Sam and Jo contribute to it.

Software teams are getting more workers. Not all of them are human.

More and more developers work with Claude, GPT and other coding agents, alongside the people on their team.

These tools keep getting more capable, but most are built for one person in one session. On a team, the work ends up split across people, conversations, sessions and providers.

As a team adds agents, the hard part moves from what a model can do to coordination: who has the context, who may do what, and how work passes from one worker to the next. Burl is being built for that.

Start with the software team.

Burl begins with developers, because a software team is one of the first places where:

  • several people work on one codebase at the same time
  • AI agents can do useful work on their own
  • changes overlap, and someone has to choose what stays
  • everyone needs to know what changed and why
  • work passes between people, and now between people and AIs

Burl doesn’t replace Git. It coordinates the work while it’s happening: who is on what, whose AI may run, and which overlaps a person has to settle.

The longer-term idea is a workspace where people, models and agents are all participants in the work.

You gave them everything. Except each other.

Put a team and its AIs on one project and it frays: two AIs edit the same file without knowing, nobody can tell whose AI changed what, and a teammate’s work lands without anyone choosing to keep it.

In Burl the whole team works in one place. Faces show who’s here. A turning ring means that person’s AI is working, and the sidebar says on what. Want to know where a teammate has got to? Ask your own AI. It’s given only what this conversation may show of their work, and their AI isn’t used.

  • Here
  • Their AI is working
  • Waiting for a person, or away

In the sidebar, Sam’s face has a turning ring and the line AI · Working on “Delivery date”. Alex asks his own AI about Sam’s work; the reply is marked “About Sam’s work · from what you can see”.

From a message to a kept change.

Four steps, the same for everyone on the team.

  1. 01

    Ask your AI.

    Write in the conversation as you would to a teammate. It goes to your own Claude, on your own account.

  2. 02

    It works in its own copy.

    Every AI change is made in a separate copy of the project (a git worktree), so the shared version stays put while it works. Your team sees whose AI is working, and on what. Close the tab and the run still finishes.

  3. 03

    It comes back with what it changed.

    You see every file it touched, and what Burl gave your AI for that reply. A teammate’s change waits until an owner keeps it.

  4. 04

    It lands, or the clash is shown.

    A kept change is part of the project, and an owner can undo it. If two changes want the same lines, the second one waits and an owner chooses what stays.

By default an owner’s own clean change to ordinary files lands by itself, and changes to sensitive files wait for a person. Clashes and stopped runs always wait, and your team can choose “Always review”.

A clash is a question, not an accident.

When two changes want the same lines, the one that would land second stops. It isn’t added, and it isn’t merged quietly. Burl names the change it clashes with and the file, and asks.

A clash card: “This change clashes with work already in the project, so it hasn’t been added yet.” Three choices follow.

Keep this version

Uses this change’s version of the clashing file, whole. What landed first in that file is replaced, and stays in history. On a teammate’s change the button names them: “Keep Sam’s version”.

Keep current version

Keeps the project’s version of the clashing file, whole. The rest of this change, in other files, still lands.

Combine both with my AI

Puts a message for your AI in the box below. Nothing changes until you send it; the result then lands or waits for review like any other change.

Never by itself.

A clash doesn’t land on its own under any team rule, and neither does a run someone stopped.

Taking turns.

An owner’s clean change that finishes while another is landing waits its turn, then lands by itself if it still can.

Undo.

An owner can undo the latest change that landed in a conversation. Changes made since by others are kept.

Hand work over. Their AI waits for their yes.

Pass a task to a teammate and Burl writes the summary for them: where it stood, what’s done, which files changed, what’s waiting and what’s next. Your private notes, imported chats and sign-in stay with you.

Sam’s screen

Sam sees a written hand-over from Alex: a note, where it stood, what’s done, the files changed, what’s waiting and what’s next. It says Alex’s private notes, imported context, preferences and sign-in were never carried.

Or hand it to their AI

Want a teammate’s AI to take the next step? It starts only when they say yes, and nobody else can say it for them. If they’re offline, it waits. One yes covers one run, and a team setting never counts as their yes.

One hand-over, two seats

Only Sam can press Approve. Until Sam does, nothing runs on Sam’s Claude. Alex’s AI picks up once Sam’s change is kept.

Your AI stays yours. Your team decides what lands.

Our mark is a set of eyes, one for every person and every AI. Their inner rings stay their own; their outer rings join into one shared shape. Burl is built the same way.

Yours alone

  • Your Claude sign-in. Used only for runs you start or approve. Never shown to anyone.
  • Your plan and its limits. A teammate can’t spend them without your yes.
  • Your personal context. Your private notes and imported context in Burl. Never shown to anyone, not even as a count, and never added to work your AI does for a teammate.
  • Chats you bring in from other AI tools. Private unless you share them.

Shared on purpose

  • The project. Its code, files and history.
  • Channels and conversations. Restricted channels stay closed to everyone outside them, and what’s in them isn’t given to those people’s AIs. The project’s owners can always see in.
  • Project memory. Each item shows who added it. Anything an AI suggests stays tentative until a person confirms it.
  • Hand-overs. A written summary of where the work stands. Private notes don’t move.
  • Who’s working on what. Whose AI is working, and on what.

Written into the code. No setting turns them off.

  1. A person decides.

    An AI can propose and do the work, but its proposal never counts as a person’s decision. Even what lands by itself does so under a rule people can change.

  2. Your AI, your yes.

    Your AI runs only on your own say-so: a run you start, a schedule you set, or your yes to a teammate’s request. A team setting never counts.

  3. Nothing is settled silently.

    Clashes and held changes are always shown to people.

And one thing we won’t overstate: each AI change is made in its own copy of the code, and a question only reads the shared one. That’s separation, not a locked-down machine for every run.

What works today. What doesn’t yet.

This version of Burl has been built since 20 September 2026.

  • Shared projects.

    Code, channels and conversations in one project, with a project memory that shows who added what.

  • Each person’s own AI.

    Everyone on the project works with their own Claude. It runs only when they start it or say yes.

  • AIs in parallel.

    Teammates’ AIs can work at the same time, and each change is made in its own copy of the project.

  • Review and undo.

    An owner keeps or discards each teammate’s change, and can undo the latest change that landed.

  • Clashes.

    Overlapping changes stop before they land. An owner picks a version, or has their own AI combine both.

  • Hand-overs.

    Pass a task on with a written summary. A teammate’s AI starts only when they press Approve.

Not yet

  • Claude only.
  • No commands, tests or installs. Your AI edits files.
  • No pushing to GitHub. Take your code out with Download code.
  • No app previews or email notices.
  • Only text-file changes can land.
  • Each teammate needs their own beta access.
  • Private beta infrastructure. No uptime SLA.
  • No pricing yet.

Burl is in private beta. Some flows have been checked with two separate accounts, some with the founder and a test account, and some currently have automated coverage only. Nothing on this page is presented as live unless it exists in the current product.

Last updated 24 October 2026.

Planned · not built yet

One team. More than one AI.

Today, Burl works with Claude. The direction is to let different models and agents work on the same project alongside people, with the person still controlling when each one is allowed to act.

For example, Claude could work on one part of a feature while another model handles a separate task. When that work is reviewed and kept, Claude would continue from the result without someone manually moving context between tools.

Different-model execution is not live yet.

Built by Conrad Schrenk

I’m Conrad, 17, and I’m building Burl.

I started it around a simple observation: AI is making individual developers much faster, but the way teams coordinate AI work is still primitive.

I build the product myself and spend a lot of my time talking directly to developers and founders to understand which multiplayer AI workflows actually matter.

Based near Cape Town, South Africa.

If you’re an investor, developer, founder, potential user, or just have a question about Burl, contact me directly. I read and reply to messages myself.

Interested in Burl?

I’m happy to talk through the product, the multiplayer AI thesis, what exists today, or where I think this goes.

Talk to Conrad

About Burl

Name
Burl
Founder
Conrad Schrenk
Location
Near Cape Town, South Africa
Stage
Private beta
Category
Developer tools / AI
Product
Multiplayer AI development
Website
burl.work
App
app.burl.work — private beta

Questions teams ask first

Something else? [email protected]

Whose Claude does the work, and what does it cost?

Your own. Everyone connects their own Claude account, one that includes Claude Code. Your AI’s work counts against your own plan’s limits. Nobody shares a key, and nobody’s plan is pooled. Burl doesn’t bill anyone today, and pricing isn’t decided.

Can a teammate use my Claude without me?

No. Your AI runs only on your own say-so: a run you start, a schedule you set, or your yes to one teammate’s request. If a teammate hands work to your AI, it waits for your Approve, even while you’re offline, and nobody else can press it: not a teammate, not a project owner, not a team setting.

Can an AI change our code without anyone looking?

A teammate’s change waits until an owner keeps it. A clash always waits for a person, and so does a run someone stopped. Under the default rule (“Review risky changes”), an owner’s own clean change to ordinary files lands by itself, while changes to .env files, database migrations, npm, pnpm or yarn package and lock files, GitHub or GitLab CI, Docker and some deploy files wait for review. Choose “Always review” and every change waits. An owner can undo the latest change that landed.

Does it work with Cursor, Codex or GPT?

Not today. Burl works with Claude only, and some company Claude accounts have Claude Code switched off, so those can’t be used with Burl unless their admin turns it on. Other models are planned, not built. Use other tools too? Tell us after you join; the short follow-up form asks.

Is each AI sandboxed?

Not in the container sense, and we won’t call it that. Each change is made in its own git copy of the project (a worktree); a question only reads the shared copy. During the beta the AI can read and edit files but can’t run commands or scripts, and no add-on (MCP) tools run. It searches and reads the web only when Web search is on for that message, and scheduled tasks always can. A repo’s own Claude settings are ignored. All runs happen on one Burl server and are kept apart by folders, not by the operating system.

Is my Claude sign-in safe on your server?

It’s kept in a folder of its own for you on Burl’s server, used only for runs you start or approve, and never shown to anyone. That’s separation by folder, not a separate machine per person, so we don’t call it isolated. Disconnect signs Claude out of Burl.

What do teammates see of my private stuff?

Your personal context in Burl (private notes and imported context) is never shown to anyone, not even as a count, and Burl never adds it to work your AI does for a teammate. Restricted channels stay closed to everyone outside them except the project’s owners. One honest gap: Burl keeps a Claude folder for you on its server, and Claude’s own settings and memory from your earlier runs in Burl live there. They can come along on any run on your AI, including one you approve for a teammate.

Where does our code go?

Connect your app from GitHub (this may not be open to every account yet), or start from a starter project when Conrad sets your team up. Burl keeps a copy on its server, where the AIs work on it, and doesn’t push to GitHub yet; you take your code out with Download code. What your AI reads and writes goes to Anthropic under your own Claude account. To be taken off the waitlist, or to have your data deleted, email [email protected].

Who is it for?

Software teams of any size, from a few people to large engineering teams, startups and in-house teams alike, where everyone has their own Claude with Claude Code. It works on your own, but most of what Burl adds (the yeses, the reviews, the hand-overs) matters once there’s more than one of you.

Build with AI. Together.

Burl is a small private beta. Join the waitlist and we’ll be in touch when there’s room for your team.

We’ll only use your email to contact you about Burl early access. To be taken off the list, email [email protected].

Already have access? Sign in

You’re in.

We’ll be in touch about early access.

Tell us about your team

What kind of team are you building with?
What are you using today?

Thanks — that helps.

Your own AI
Each person’s AI runs on their own Claude account, and only when they say yes.
Its own copy
Every AI change is made in a separate copy of the project.
A person decides
A teammate’s change lands when an owner keeps it, and a clash always waits for a person.

We’ll be in touch about early access.

You’re in.

We’ll be in touch about early access.