Skip to main content
A branch node is a shared workspace. Everyone who opens a running branch in the editor connects to the same node and works in the same live environment — the same working tree, the same builds, the same agent sessions, the same task board. There is no separate “join a session” step: opening a running branch is joining the session.

Presence

The top bar shows who is connected to the branch node right now, and the file explorer marks which files each person currently has open. Presence spans everything on the node — editing, chat, and meetings — so you can always see where your teammates are working.

Editing together

Collaborative editing is opt-in — turn it on from the collaboration controls when you want to work in the same files simultaneously. With it enabled:
  • Concurrent edits use operational transformation. The node transforms edits from connected participants against the shared document. Reconnect and full-sync recovery have separate limitations; see saving and draft recovery.
  • You see each other’s cursors and selections, labeled with names, live in the editor.
  • Saves use the shared document. Saving asks the node to persist the session’s authoritative content. The acknowledgement identifies the saved revision; subsequent edits still need saving.
Same sign-in, two windows. With collaborative editing on, a node keeps one live connection per signed-in identity for a file open in the same editor pane group. Opening that file in a second browser window under the same sign-in in the same pane position hands the connection to the newer window; the first window can show a collaboration error or stop receiving edits. To work on one file from two windows with one account (for example, to show co-editing), open it in a split editor pane in the second window — the verified path.

Team chat and meetings

The node hosts real-time collaboration channels for the branch:
  • Chat rooms — text messages, code snippets, and file sharing, with typing indicators and full message history.
  • Meetings — video calls with screen sharing between people on the node, in a windowed, fullscreen, or collapsed layout. Media streams flow peer-to-peer; the node only coordinates the call.

The AI agent is shared too

Agent chat sessions run on the node, not in your browser. Anyone on the branch can browse the session history and resume a conversation the agent had with someone else — the agent’s work on the branch is part of the branch’s shared context, not a private thread.

What’s shared, what’s yours

Terminals are personal in the editor, but the processes they start run on the node — a dev server one person launches is reachable by everyone on the branch through the node’s proxied preview URL.
When you connect through the managed platform, your signed-in identity is asserted by the platform and used for presence, chat, and terminals. Connecting directly to a node you run yourself, you pick a display name; platform-verified identity everywhere is still being rolled out.

Durable state travels with the branch

The node itself is ephemeral. A normal Stop keeps its saved workspace; it does not commit or push files for you. Unsaved editor text lives in the open tab; reloading or closing that tab loses it. Running processes end when their server stops. Save and commit work you need to retain. Opening a deliberately stopped branch leaves it stopped until someone explicitly starts it again. With collaborative editing on, a replacement server may not have unsaved text that the previous server held. A draft joining a shared session can also differ from that session’s text. The editor preserves differing unsaved text in a copy-only recovery tab and disables Save. Copy the text somewhere safe before closing the tab, then reopen the file to work from the replacement server’s saved version. Cancelling the discard confirmation keeps the preserved tab open. Save also refuses while the shared session is disconnected; wait for it to reconnect or copy your text before leaving the tab. The committed record of the branch’s work lives in the .reasonos/ tree at the workspace root: Because this tree is committed, the record of AI-assisted work moves with the branch through git: push the branch and a teammate — or a fresh node — gets the full history of chats, plans, and tasks. Merge the branch and the record merges with it. Per-server ephemera — build outputs, toolchains, checkpoints, notifications — stay in the gitignored .rbs/ directory and never leave the node.

The task board

The Branch tasks view is a kanban board scoped to work on this branch — not a company-wide project tracker. Cards support descriptions, step checklists, comments and questions, and links to related plans, memories, and chats.
  • Run with agent starts an AI agent session seeded from the card and opens it in the agent panel; the card tracks the work.
  • Questions the agent asks and lifecycle events arrive in the notification center and deep-link back to the card.
  • Card lifecycle reconciles against git — when a branch is merged or abandoned, its cards are badged accordingly.
The board’s columns, WIP limits, and the prompt an agent receives when picking up a card are configured in the committed .reasonos/tasks.rbs file, so the whole team (and every node) sees the same board. Project Work issues are separate records in the managed platform. Their Run with agent and Comment and continue actions keep replies on the issue itself. The AI Work pane also lets you work with an agent alongside project pages without entering the editor; hiding that pane does not stop its conversation.

Switching branches

Since durable state is in git and live state is on the node, moving to another branch is simply connecting to that branch’s node — pick the branch from the top bar and the editor navigates there, provisioning a node if the branch doesn’t have one yet. Your teammates on the original branch are unaffected: nothing checks out over their working tree, and their node keeps running.