A session your
whole team
can act in
Not a transcript they can read. Anyone on your team can open the same live agent session, take a claim, redirect a running agent, or take over work you started. OpenFloor is what keeps four of them at once from corrupting the repository.
Above
One session in the openfloor repository. Three people, four agents, and
every path any of them can write. Depth into the frame is session time, and each box
is one teammate holding a claim. Ryan's agent and Ali's agent both reached for
app/page.tsx, so the session stopped before either of them wrote.
The paths, the claims and the collision are derived from the repository. The pace the
agents move at is illustrative.
Multiplayer is not a share button.
Putting several people in one agent session is the easy half. The hard half starts the moment two of them dispatch work, because now two agents are writing the same repository and no amount of shared visibility stops them.
Read access is not collaboration. Neither is a shared prompt box. A teammate is only useful if they can act: take a claim, narrow the scope of something already running, take over work you started and finish it. Every one of those actions changes who is allowed to write what, so the session has to know who owns which paths at every moment, and has to be able to say no.
That arbitration is the product. It is why OpenFloor is multiplayer from the first event rather than a solo tool with sharing bolted on later, and it is the part that does not work if you add it afterwards.
Long-running agents force the issue. A task that runs for an hour outlives the attention of the person who started it, so somebody else will need to answer a question, approve a command, or take it over before it lands.
Three things a teammate can do that a link cannot.
-
Watch
See it while it happens
Every agent's current step, the paths it holds, and the checks it has passed, as structured state rather than a scrolling log. Someone who joins an hour in reads where the work is instead of scrolling to find out.
-
Redirect
Steer something already running
Send an instruction to a working agent, narrow its scope, or stop it. You are not waiting for a turn to end and you are not opening a new thread. Anyone in the session can amend the task contract an agent is working against.
-
Hand off
Leave without stopping the work
Dispatch, close your laptop, and let a teammate pick it up mid flight. The session holds the objective, the claims, and the history, so none of it lives only in your chat window.
Several people dispatching agents at once must not corrupt the repository.
-
01
One session, one branch
One objective, one repository, one canonical branch. Every participant reduces the same ordered event log to the same current state, which is what makes joining late cheap.
-
02
Claim before you write
Each task declares the paths it owns. Claims are exclusive for writes and advisory for reads. When two claims intersect, those two tasks pause and everything else keeps running.
A claim is a path prefix. On a sorted path list that is a contiguous interval, so a collision is an interval intersection and can be found before a single line is written. That is what the field above is showing.
-
03
Work in isolation
One branch and one Git worktree per task, prepared and torn down by a local runner. No two agents share a writable directory. The runner connects outbound, so nothing opens a port on your machine.
-
04
Integrate under checks
Candidate patches land in a controlled order on a temporary checkout. Checks run per task and again against the combined state. Any integration can be rolled back on its own.
A prototype, described accurately.
- Session model and reducer
- Real. Ordered events reduce to current state.
- Events
- Mocked from a fixture. Not yet produced by a runner.
- Agent adapter
- Not built. Codex first, Claude Code next.
- Auth and persistence
- Deliberately excluded from the first slice.
- Scope
- One repository per session. Desktop is the primary surface.
Decisions still open
- Whether integration is cherry-pick first, patch-apply first, or supports both.
- Task cancellation, timeout, and orphaned worktree recovery semantics.
- The minimum permission policy for commands, environment variables, and network access.
- Retention and privacy for raw agent logs and command output.
Published because a team evaluating a control plane should see what is undecided before they see a feature list.
Engineering is where we start, not where this stops.
Anywhere a team already crowds around one problem, there should be agents all of them share. Sales teams working a deal. Support resolving a ticket. Lawyers drafting a contract, analysts building a model, marketers shipping a campaign.
Each of those is the same shape underneath: several people, several agents, one artifact that must not end up inconsistent. The arbitration changes, the problem does not.
Code is first because it is the hardest version. Many parallel writers, one shared artifact, and a merge that fails loudly the moment coordination is wrong. Everywhere else, a bad merge is a document someone has to reread. Here it is a broken build, which means we find out immediately whether the coordination actually works.
What do you run in parallel?
If your team already runs Codex or Claude Code side by side on one codebase, we want you on the first real session. Tell us what you run, how many at once, and where it currently breaks.
Chat is a command surface for dispatch and steering. The session state underneath it is the product. Git decides what the code is: a reviewer can open a remediation task but cannot pass a failing check or bypass repository permissions.
Or write to hello@openfloor.ai