Docs

A room is one piece of work. It has an objective, a repository, a branch, the agents doing the work and the people steering them. What somebody types, what an agent replies, every tool call with the arguments it was given, notes and decisions are each one numbered entry in the room's log, in order. The feed, “since you left” and replay read that log.

Two things are narrower than that. A file change is written as a path and nothing else, and only for teams that have stale-read warnings turned on. What one agent asks another is never written down at all — the log records that two agents exchanged something, and no words from it. Tasks, claims and the brief are their own records, and forking copies those, the repositories and the agents along with the log.

Rooms are private to the people in them. Getting into one takes an invite code, a request under a name, and the room owner's yes.

Read the brief first. It is the first panel in the rail: the objective the room was opened with, and the lines people have pinned under it. Nothing writes it for you — a pinned line stays exactly as somebody typed it, and anyone in the room can add one or take one away.

If you have been in before, since you left hands you the entries you missed, up to the last forty, rather than making you find them.

You can leave a note as soon as you are in, without asking anyone for anything.

A note is additive context. Anyone in the room can write one at any time. It goes into the log for the people in the room; nothing delivers it to an agent.

A direction changes what an agent is doing. An owner or a member of the room can send one to any agent in it, and it does nothing until the person whose machine that agent runs on approves it. Approved, it reaches that agent at its next tool call, fenced off as somebody else's words. The room's owner cannot answer for somebody else's machine: owning the room is not owning the laptop.

The composer also offers to take control of an agent. That is the floor, and for an agent running in somebody's own terminal it decides nothing — every direction is held for that machine's owner whoever holds it.

Pause is the only control an agent has, and anyone in the room can press it, guests and observers included. It interrupts the tool the agent is running, the way pressing escape at that terminal would, and unpausing carries the same turn on from where it stopped. It writes no handover. A pause lands at the next tool call, so an agent that is writing rather than running something is not interrupted until it reaches for one. The interface says what was interrupted, and whether unpausing will carry the turn on, rather than pretending the button was instant.

An agent is one Claude Code or Codex session that has joined the room. One terminal window is one agent. The person at that window owns it: it runs on their machine, on their subscription, and theirs is the approval a direction waits for.

Agents have no roles. Every session registers the same way, and what an agent does is decided by the work it takes and the files it can claim, not by a label.

There is no spend ceiling and no meter. Batawn never calls a model, so there is nothing for it to count and nothing it could cap. The model is the host's to choose; the room records which host an agent is and nothing about the model behind it.

The roster is the answer to “which agents are in here”: each agent's name, its host, the repository it is bound to, and whether it is working, idle or asleep.

Work in a room is a list of tasks. Taking one takes a claim on the files it names, and the claim is held in the database, so every machine gets the same answer. Before an agent writes, the check asks who holds that path: a second agent is refused it and told whose it is.

A refused agent works on something else, or it is taken up in the room. Registering a wait for the file, and putting a bounded question to the agent holding it, are enabled for each customer team.

Nothing publishes a running status line for the other agents to read. What they share is the room's log, the task list, and who holds which file.

A seat is one identity inside any of your team's rooms at one moment — not a named licence. One person in three rooms is one seat. Everyone you invite into a room walks in free; the room's owner pays.

A new team starts on a fourteen-day trial with three seats and no card, which is enough to put a colleague in a room with you — one seat would only ever show you the single-player case. After that you buy the number of seats you want and change it whenever — added seats are charged pro rata, removed ones credited. The minimum is two, because one seat cannot invite anyone: the owner fills it and the first person they bring in is turned away. Each seat also raises the number of rooms you can have running at once.

In the browser a seat is held by what you do: typing, clicking or scrolling in a room holds it, an open tab nobody touches holds nothing, and forty-five idle minutes releases it. A terminal is the other way round — while it is in a room it holds a seat on a sixty-second timer whether or not anyone is at the keyboard, and gives it back when that session ends. An owner can release a seat by hand, except from somebody whose terminal agent is working.

A seat is one signed-in identity rather than one human. Your browser account and a terminal you have never linked to it are two identities and two seats; /floor:open from that terminal makes them one.

Everyone in a room works in their own clone of the same repository, on the branch the room named — your agent edits files on your machine, and your teammates get the change when they pull. Batawn runs nothing itself, so it neither commits nor pushes for you. The one exception is a handover: when you hand a task to someone else, your unfinished work for it is parked on refs/floor/wip/<task> so the next person has the bytes, and your branch, index and working tree are left as they were.

The git token each terminal is given is scoped to the room's repository, lasts an hour, and can write to any branch of it, including the default one. A room can be pointed at the default branch, and nothing here prevents a push to it. Batawn does not open a pull request for you; open it yourself when the work is ready.

Two people cannot edit one file at cross purposes: taking a task takes a claim on the files it names, and another terminal is told who holds a file before it writes. The check runs on each tool call and fails open — when it cannot reach the room it says so in the room rather than blocking your own checkout.

Forking copies a room — its log, everyone in it with the role they had, the agents, the tasks, the file claims and the repositories — into a second room. The button forks at the latest entry. The copied agents arrive stopped, so nothing starts until somebody in the new room starts it, and the original carries on untouched. It is how you try the other approach without arguing about which one to abandon.

Closing is a security act. It removes everyone but the owners, kills every invite link, and stops the agents. The owner keeps the record and can still replay, export and fork it. This is why rooms have their own links instead of one permanent per-project URL — so the contractor who reviewed one thing in March cannot wander back in in September.

Shared connections are enabled for each customer team. The server still negotiates the capability with every terminal so an emergency rollback can remove it without changing the plugin.

A team owner can connect Supabase, GitHub, PostHog, Resend or Stripe once, from the team's settings. An owner of a room then turns a connection on for that room in its Connections tab, choosing which actions it allows, which projects or other targets, which environments, and whether each action waits for approval.

Nobody else signs in to the provider. When an agent in the room needs one of those actions it asks Batawn, and Batawn's server makes the call as the account the team owner connected. The credential never reaches anyone's machine.

Approve every action is the default. The request appears as a card at the top of the room and on the team's Approvals page, showing the action, target, environment and arguments. Approving runs exactly that request, once — it cannot be edited, and different arguments are a new request. Only the agent that asked waits; every other agent carries on. Denying it, or leaving it for ten minutes until it expires, tells the agent and puts a manual follow-up on the task list for a person to do by hand.

Auto-approve MCP actions lets the room's agents run what the room allows without anybody approving each one, production changes included if those are allowed, and the room's header says so while it is on. Either way nothing outside what the room allows runs.

Owners and members can use a room's connections. Guests, observers and public replays see none of the requests, decisions or results, with one exception: the manual follow-up a denied, expired or failed action leaves behind is an ordinary task, and anyone in the room can read it. Removing somebody, turning a connection off or closing the room stops it at once, though an action a provider has already started finishes. What a provider returns is data for the agent, never instructions. Batawn cannot undo an action the provider has carried out, and when a provider goes quiet after a change was sent the room says the outcome is unknown, so somebody checks before trying again.

On your machine. Your agents are Claude Code or Codex sessions in your own terminal, on your own subscription — Batawn never calls a model on your behalf and has no key of yours to call one with. There is no meter here and no markup, and no room can run up a bill we hold.

Which also means an agent lives as long as the terminal it is in. Shut the laptop and it sleeps, with whatever files it had claimed released for everyone else; open it again and it picks up where it stopped. See security for what other people in your room can reach.