Skip to main content
A branch node is a shared workspace. Everyone who opens a 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 the 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 merge automatically. Two people typing in the same file — even the same region — never lose each other’s changes; the node transforms and merges every edit in order.
  • You see each other’s cursors and selections, labeled with names, live in the editor.
  • Saves are coordinated. Saving writes the session’s authoritative content on the node and every participant’s unsaved indicator clears together.

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 — it can be stopped, rebuilt, or replaced without losing anything that matters. Everything durable lives in the committed .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 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.

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.