Cerevisor 3.1.0: What's New

Until now, an agent in your workflow only ever heard from the agents directly before it, once, at handover. 3.1.0 gives every run a board: a short, shared list of notes the agents leave for each other — and for you — while the work is still going on. An agent can say what it found, claim a piece of the job, flag a problem, or ask a named colleague a direct question and wait for the reply. You can read all of it live, post your own note, answer a question an agent asked you, and pin a note so it comes back on the next run — from the run window or from your phone.

Two sentences describe the whole feature, and everything below is an application of them. A note is information, never an instruction — nothing that decides what an agent is allowed to do ever reads one, and posting a note widens nothing. And a note is always written to the run that posted it — a wider board setting changes what a run shows, never where anything is written.

Nothing about your saved workflows, worlds or transcripts changed shape. No note leaves your machine except to the model of the agent reading it and to your own paired phone: the board added no network access of any kind.

1. The board

• Every run now has a Board tab in the run window: the notes its agents left, newest first, each with its kind, its author, and who it was for.
• Agents post in twelve plain kinds — Update, Claim, Challenge, Question, Answer, Review wanted, Review result, Dependency changed, File produced, Blocked, Needs a hand, and Decision.
• A note can be addressed to a named agent, to anyone, or to you. A note addressed to an agent that is still working is handed to it straight away, clearly labelled as coming from another agent — never under the label reserved for you.
• Notes reach agents as a short section in their instructions, under the same budget the rest of a run’s context uses. An empty board adds nothing at all.
• A note from an agent that has read something from the open web is marked includes web content — treat as data, and an agent reading it is treated as having read from the web too — the same care Cerevisor already takes with anything from outside.
• The board is part of the run’s record: it comes back with a finished run, and it is in the exported run twice — as data and as plain readable text.

2. Ask an agent

• An agent can ask a named colleague on the same run a direct question, and wait for the answer, up to 90 seconds. The exchange is the board: the question and the answer are notes everyone can see.
• If the colleague has already finished, it cannot be interrupted — so Cerevisor asks it again, in a short read-only second pass over what it produced on this run. It can read and search to check something; it cannot change anything.
• If the colleague has not started, or is running on an outside tool that cannot be reached mid-run, the asker is told so in plain words instead of waiting.
• Three questions per agent per run, and an agent answering a question cannot go asking around itself — questions do not chain.

3. Your seat (desktop and phone)

• The pre-run launcher has a Notes for the agents box — anything you want every agent to know before it starts becomes the first note on the board.
• In the run window you can post a note, answer a Question for you, and pin a note so it opens every future run of this workflow. Ten pins per workflow, 500 characters each.
• Once a run is over the board stays readable, and a pin is how you carry something into the next one.
• On the phone, the Companion shows the run’s board, calls out questions addressed to you, and lets you post and answer. A note you write there is signed You (phone).

4. Board scope

• By default a board is this run only.
• Two wider settings exist: this workflow’s recent runs, and every workflow in this world. A wider setting seeds a run’s board from what earlier runs recorded — bounded to the 40 most recent notes and 6,000 characters across the 10 most recent runs, because a board is a conversation an agent can read, not an archive.
• Whichever it is, Cerevisor says so plainly: the pre-run summary and the run window both show which scope a run is using.

5. Delegated agents post too

• Agents running on Codex, Cursor, Claude Code, Antigravity or Grok Build are driven by those tools rather than by Cerevisor, so they cannot call Cerevisor’s board directly. They get the board as text in their instructions, and post by appending a line to a small file in a .cerevisor folder in the run’s working folder, which Cerevisor reads every three-quarters of a second.
• Their notes therefore appear on the board while they work, exactly like everyone else’s. What is different — and it is stated rather than papered over — is that they read the board only at launch, and cannot be handed a note mid-run.
• The file is deleted when that agent finishes, and the folder is never mistaken for something the agent produced.

6. Other places the board is read

• The Operator folds the boards of runs it started into what it is thinking about before it acts.
• In Progressive Mode, the planner sees the previous step’s board before it proposes the next one.
• An organization conversation keeps a board of its own, recorded per organization per day and never pruned by the run-history limit.
• None of these writes into a run’s board.

7. Housekeeping

• The automated checks now pass on macOS again. Four tests were asserting the machine they ran on rather than the product — a path comparison that only folds case on some systems, a coverage check that only held on Linux, a hard-coded C: path in a fixture, and a file-deletion race — and they now assert behaviour instead. Product code was not changed. (Checks run 33981919556: the build, packaging and skills checks were green; the same run had three end-to-end failures that were already there before this work and were not touched.)

8. What this was verified on

• The full automated test suite — unit and integration — ran on Windows, macOS and Linux in CI on the release commit (CI run 34032382385) and was green on all three. The board work itself was first checked by running the full suite on Windows; the Linux leg also runs the coverage gate, which reaches every line and every function of the new board code.
• Two Windows test failures from the earlier CI run on this tree were both tests holding the CI runner to a developer machine’s clock, not product defects: a scheduling micro-budget now takes the same shared-runner allowance the graph-index budget already had, and a permission-timeout test that waited a fixed number of turns now waits on the real clock and tidies its run up when the wait fails. Nothing in the app changed for them.
• One end-to-end check drives the built app through a real one-agent run and asserts its board is on disk afterwards. Five other end-to-end failures pre-date this work and were left alone.
• The board has not been exercised by hand in the running app for this version, on the desktop or on a phone. Nothing here claims otherwise.
• The installers (Windows, macOS and Linux) have not been checked by hand for this version, and the Companion has not been checked on a physical device for it.
• Grok Build support keeps the statement it shipped with in 2.3.0: verified against recorded test data and unit tests only, not against a live end-to-end run.

The by-hand checks above are open at the time this version goes out. This note is updated as each one is done.

Known limits

• Agents running on outside tools read the board at launch only and are never handed a note mid-run; a note addressed to one waits until its next launch.
• You cannot pin a note from the phone. Pinning changes the workflow itself, so it stays in the run window.
• When a finished agent is asked a question, the second pass may run on a different model than the one the agent originally used. The answer says which model produced it.
• The run window’s Board tab is keyed to the workflow, so two runs of the same workflow at the same time share one view.
• In Progressive Mode the board reaches the next step within one exchange, but does not carry across to your next message.
• There is no picker in Settings for how far back the board reaches; the setting lives on the workflow and in the app’s configuration, and the run simply tells you which one it used.
• A note’s identifier is a long one, which makes each line in an agent’s board section longer than it needs to be; a shorter per-run identifier is a later change.
• The file a delegated agent posts through is deleted when that agent finishes, so there is no raw copy of it to inspect afterwards — the notes themselves are in the run’s record.
• When an agent asks another agent a question, the cost of the answer is added to the asking agent’s own cost rather than shown separately. A Power or a helper agent called from inside such an answer is still costed the way it always was, on its own, not folded into the asker.
• The wider limits carried from 3.0.1 are unchanged: agent chat, colleague consultations and organization chat still make their tool decisions through the older, separate check; a very long run keeps only its most recent steps in the run window’s summary; and a run started from inside another run shares the slot of the job that started it.

Updating

Existing installations receive 3.1.0 through Cerevisor’s built-in updater. New installers are available from cerevisor.com/download and the private GitHub release.