Project Work
Open a project and choose Work to find its issues and cycles. An issue holds its description, status, assignee, labels, subtasks and comments. Links connect it to branches and agent sessions. Organization-level initiatives can bring together work from multiple projects. Screenshots, files and linked drawings travel with the issue. See Attach files and drawings to issues. To bring an exported project from another ReasonOS installation into Work, see Import Work from ReasonOS. Preview first and choose whether to add missing records or catch up supported imported fields.Cycle boards
A board is a view of one cycle’s work, so each cycle has its own. Open Work › Cycles and choose a cycle to see its issues in columns by status. The project’s issue list stays a list.- Drag a card to another column to change the issue’s status.
- From the keyboard, use the card’s ⋯ menu and choose Move to a status. The menu works whichever way the board is grouped. Arrow keys move through the menu, and Escape closes it.
- If ReasonOS refuses a move, the card goes back to its column and the board shows the reason.
- If ReasonOS can’t confirm a move, for example because the connection dropped, the board says so instead of guessing, and reads itself again to show where the issue really is. If it can’t read the board either, it asks you to refresh before moving that issue again.
All work: issues across projects
All work in the top bar lists existing issues from every project you can read in the organization. Projects you can’t read never appear, and cycles and branches stay with their own projects. Choose an issue to open it in its project’s Work.- Narrow the list by project (All readable projects by default), by scope (Active, Backlog, All issues or Archive), by workflow category (Backlog, Todo, In progress, Completed, Canceled), and with the usual issue filters: search, assignee, creator, priority and dates. Status, label, branch and cycle filters belong to a project, so they appear once you choose one.
- Sub-issues are listed only when you turn on Sub-issues; otherwise only top-level issues are listed.
- The filters are part of the address. Back, Forward, reload and a shared link return to the same list. If the address names a project you can no longer read, All work says so instead of quietly showing every project.
- The list changes only when you ask. It doesn’t refresh on a timer, so the row you’re looking at stays put; choose Refresh to read it again. Issues come 50 to a page, and if the list has shrunk since you chose a page, First page takes you back to the start.
Work in the workspace
In a branch workspace, open the Work view to see the project’s issues without leaving the editor. Choose Project for the project’s active issues, the branch name for the issues this branch delivers (linked to it, or named by the issue key in the branch name), or Backlog. Choose an issue to open it in a panel over the right side of the workspace. The panel is the same issue page as in Project work: change its status, assignee, priority, labels and cycle, edit it, comment, attach files and link branches, all without leaving the workspace. The Work list updates as soon as you save a change. Press Escape or the close button to return to the list.- Your place is in the address. The open issue and the Work view’s scope are part of the workspace URL, so reload, Back and a shared link come back to the same issue.
- Unsent writing is kept in this tab. The title, description, a new comment, a reply, or an edit of a posted comment you started survive closing the panel, opening another issue, Back and Forward, and reloading the page. They’re kept for the browser tab, not across tabs or after the tab closes, and files that finished uploading stay attached to what you were writing.
- A file still uploading can’t be kept. If you close the panel or open another issue while a file is uploading, ReasonOS asks first; leaving then keeps the file on the issue, but not in what you were writing.
- Pages outside the workspace open in a new tab — Project work, a new issue, a cycle board, a change request, an initiative — so the workspace, its open files and its chats stay where they are.
- Run with agent on this workspace’s branch starts the agent here. For another branch it opens that branch’s own workspace in a new tab; opening an issue never moves this workspace to another branch.
Run an issue with an agent
Choose Run with agent beside the issue title. With one linked branch, ReasonOS uses that branch. With several, choose which one; with none, use the branch creation/linking flow first. The UI saves a visible instruction comment before it asks the branch agent to run. You stay on the issue page, where replies appear in Activity. This is not an unconditional “create a new branch every time” operation. Existing issue/branch relationships are reused, and choices are requested when the target is ambiguous. Agent model choices and credentials come from the applicable session and AI configuration.Comment and continue
Write a follow-up and choose Comment and continue, or mention@agent in
the comment. ReasonOS saves the comment first, then asks the agent to continue
from that exact comment. An ordinary comment without either action does not
wake the agent.
Saving a comment and the agent accepting it are separate outcomes:
- Accepted: the agent received the request. Its reply or work result will appear in the issue activity; acceptance does not mean the work is done.
- Refused: the UI explains what prevented starting. Your saved comment remains, and a retryable refusal can offer Continue with the agent on this comment without posting the comment again.
- Unknown: the request may have reached the agent but its acknowledgment was lost. Read the activity before trying again; the request is not automatically replayed.
Plan or review without starting a coding run
Use AI Work alongside project pages without opening the editor. Plan with AI on a cycle and Review with AI on a proposal prepare editable prompts. Review and send them yourself; opening these actions does not send a prompt automatically.Delegate to a linked branch
An agent can request continuation on another branch linked to the issue, using an existing instruction comment written by you. Starting a stopped target requires explicit authorization and consumes a server slot. Delegation does not switch the current shared server’s branch, and an accepted delegation does not mean the target finished the work. See delegation outcomes.A branch is the execution environment
When you open a branch in the ReasonOS editor, you connect to that branch’s node. There is no separate “join a session” step — everyone who opens the branch lands in the same live environment, and switching branches means connecting to a different node, never checking out over anyone’s working tree. Pick a branch from the top bar and the editor navigates there. The project record stays in the platform. Branch execution has its own state:- Live state stays on the node — the working tree, running builds and dev servers, agent sessions in flight, presence, chat rooms, meetings. Nodes are replaceable, but replacing a node is not the same as backing up uncommitted files or live processes. Keep work you need in durable storage.
- Git-backed branch records — task cards, saved chats, plans and memories
live in
.reasonos/. Commit and push them when you want that record to travel with the branch. Project issues and their comments are not stored here.
What travels with the branch
The committed.reasonos/ tree is the branch’s work record:
Because the record is committed:
- Push the branch and a teammate — or a freshly provisioned node — gets the full history: the board, the conversations, the plans, what the agent learned.
- Merge the branch and the record merges with it, landing in trunk as a durable account of how the work happened.
- Nodes stay disposable. Per-server ephemera — build outputs, toolchains,
checkpoints, notifications — live in the gitignored
.rbs/directory and never leave the node.
Checkpoints are the deliberate exception: they are
per-node safety snapshots for undoing agent changes, not part of the branch’s
committed record.
Tasks: the board on the branch
The editor’s Branch tasks view is a kanban board of the work being done on this branch — deliberately not a company-wide project tracker. By default it shows cards for the current branch plus the unassigned backlog, with an all-branches filter when you need the wider view. Cards carry a description, an ordered step checklist, a comment thread, and links to the plans, memories, and chats that produced them — so a card’s Linked section can reopen the exact conversation or plan behind the work. Drag cards between columns as work progresses; card lifecycle reconciles against git automatically, so cards for merged or abandoned branches close themselves. Two agent-facing actions live on the card itself: Run with agent hands the card to an agent session, and writing@agent in a comment gets the agent to
respond — or do the work — in that comment thread. The
task board guide covers the board, its .rbs
configuration, and the agent workflow in depth.
Don’t confuse the board with the Tasks checklist that appears inside an
agent conversation. That in-chat list is the agent’s own working checklist for
the current run — ephemeral and session-scoped. Work that should outlive the
session belongs in a durable record: a project issue or a branch card,
depending on what it describes.
Plans and plan mode
Plan mode separates deciding what to do from doing it. The agent chat header has a toggle that switches the session between Agent and Plan; in plan mode the agent can read code, search, and reason, but editing files and running commands are refused outright — investigation only. While planning:- Plans appear as cards in the conversation, marked read-only: the goal, a checklist of steps with statuses, and priorities. Updates stream in as the plan evolves.
- The agent asks structured questions when it needs a decision from you — option pickers or free-form answers, right in the transcript. The agent waits for your answer before continuing.
- Finishing is an explicit gate. When the plan is concrete enough to act on, the agent presents it and asks to start work. You can approve, approve while letting file edits proceed without further prompts, or send it back to keep planning — with your feedback.
.reasonos/plans/ tree and can be linked
to task cards, so the design travels with the branch alongside the code it led
to.
Chats: the conversation record
Agent conversations happen in the editor’s AI pane — multiple tabbed chats, streaming responses, and a Previous conversations history you can reopen and resume. Sessions run on the branch node, not in your browser, which makes them shared by construction: anyone on the branch can browse the history and pick up a conversation the agent had with someone else. Saved sessions persist to.reasonos/ai/chats/ as JSON with a readable
Markdown mirror, so the reasoning behind a change is reviewable in the repo —
in a diff, in a code review, or from a future session on the same branch.
The node also hosts team chat rooms for the humans on the branch — text,
code snippets, and file sharing with typing indicators. Room history lives on
the node for the life of the session; the durable, committed record of the
work is the agent chats, plans, and task comments.
Meetings and presence
Presence is ambient in the editor: the top bar shows who is connected to the branch node, the file explorer marks which files each person has open (click to open the file and join them), and with collaborative editing enabled you see each other’s live cursors and selections. The node also hosts meetings — video calls with screen sharing between people on the branch, in a windowed, fullscreen, or collapsed layout. See Collaboration for the full picture of what’s shared on a node and what stays yours.How agents take part
Agents can work with either record through its corresponding tools:- Project issues stay in Work. ReasonOS MCP tools read issues by number, update status and post comments. Browser issue actions and terminal agents operate on those same project records; they do not need a stale copy in the branch’s files.
- They work the same board. Agent sessions carry task tools that read and write the very board the editor renders — checking off steps, moving cards, commenting, and filing follow-up cards for work they found but didn’t do.
-
You can hand them work two ways: Run with agent on a card seeds a
session from the card and keeps the session linked to it, and
@agentin a card comment gets an answer — or the work itself — in the thread. - They ask instead of guessing. Questions the agent posts on a card, and agent run outcomes, arrive in the editor’s notification center and deep-link back to the card or the chat session.
-
They remember for the branch. Lessons and taste the agent records are
committed under
.reasonos/ai/, so every future session on the branch — no matter who starts it or which node runs it — begins knowing what earlier sessions learned.
Above the branch
The branch board tracks execution on a branch. Project issues and cycles, organization-wide initiatives, and the review inbox live in the managed platform. Use links to connect project records to branch execution; there is no automatic migration from branch cards to project issues. If a managed branch already has cards on its board, you can move them into Work once. For a one-time move from a Linear project into a managed project’s Work issues, see Import a Linear project.The platform Work suite and app-wide AI Work pane require the managed
application. A self-run node’s branch board is not the project issue service.
Learn more
Task board
The branch board in depth: cards, lifecycle, configuration, and running tasks with the agent.
Collaboration
Presence, co-editing, chat and meetings, and the shared-vs-personal split on a branch node.
Coding agent
The agent that shares your branch: engines, graph-first tools, sessions, and memory.