AI Workbench · Mojo Up Docs

Every release, newest first. The desktop app shows the same notes under What's new after it updates, and a node prints its version with mojoup-node version.

0.90.22

Mojo Up AI Cloud has moved to service.mojoup.ai, and its console to cloud.mojoup.ai. The workbench, the node, the installers and the update feed use the new names. Sign in to Mojo Up again once after updating; an Enterprise organisation on its own AIOE is unchanged.
No command prompt flashes up on Windows. Every helper the workbench starts, the memory engine's probes included, now runs without a console window.

0.90.21

Local models: estimated memory use before you load. The settings card leads with what loading would take, GPU and RAM, against what this machine has, live with every slider; a warning when it is tight and a sentence saying what to do when it will not fit.
Local models: a better settings card. Model information with capability chips (vision, tool use, reasoning), sliders for context length (up to what the model was trained for), GPU offload over the model's real layer count with the GPU/RAM split, experts on CPU, threads and parallel slots, a reasoning-budget ladder, speculative decoding as one choice, unified KV cache, RoPE and seed under Advanced.
The context slider says what is left. The card shows how much of every window the workbench's own instructions and tools take, measured from real sessions where it can, and what remains for the conversation.
Faster writing from Discover. A model that ships a speed head (MTP, EAGLE-3, DFlash, DSpark) gets it with the download and uses it automatically; the model card's recommended sampling is read and offered as a preset.
Covers with Stable Diffusion 1.5 follow the style again. A tag-reading model is given the style first and a short subject, not the cover's paragraph.
CUDA for local models on Linux and WSL2. The bundled llama.cpp moves to build b12024, the first with Linux CUDA builds, so an NVIDIA card has its own stack on every platform as AMD has ROCm, and a WSL distro with an NVIDIA card runs models on the GPU automatically instead of on the CPU.
The floating monitor says used and total for memory and disk ("194 / 954 GB"), so the used figure no longer reads as the drive's size.
Big pictures get an overview. A picture with more boxes than read at a glance (every one of a project's tables, say) shows itself in miniature in the canvas's corner with the viewport framed, pannable like every other overview.
A memory update that times out on Windows now ends its python with it, and the sidebar's "more below" cue has a row of its own.
Full access stays on screen. The composer's Access badge no longer disappears while a session runs.
With AIOE 0.80.1 (PR #62) the Token economics view reads your organisation's numbers from a workbench; until then it says why it shows this computer's.

0.90.20

Workflows ask who works each step. Opening a workflow with agent steps nobody here can work asks one question per step, by the step's name, with the name it was written for as the hint — so a workflow from your organisation with its people stripped gets the same question. A pick spreads to the other steps written for the same name.
Workflow fields know their variables. Every templated field has Insert ▾ (earlier steps' answers, the run's inputs, the trigger's fields — only what the run really sets), autocomplete when you type {{, a "Reads as:" preview in words, and a draft problem for a reference that does not exist here.
The HTTP step picks a kept key from the keys on this computer, offers "Add a key in Settings › Secrets…", marks a key the file names that you do not have, and says how it is sent (Authorization: Bearer).
The Data view draws every table. The picture keeps the ten tables that read best by default; All tables draws every one, key fields only, to pan and zoom, with nothing dropped. The project's copy of a repository's data now drops fields before it drops tables, so 237 tables read as 237 (fields are in the repository's own Architecture), and the view says what the copy left out.
The AI video card no longer fails on its time limit, and says the Designer.

0.90.19

The Diagrammer is the Designer. The specialist that drew your diagrams now makes what people look at: diagrams of your architecture and roadmap, pictures, interface mock-ups, workbench apps and short videos. Existing Diagrammers show as Designer and take on the wider brief at their next start; a member still called "Diagrammer" is renamed Designer, any other name stays, and your own saved instructions are never touched.
AI video. Settings › Models has an AI video group: fal and Higgsfield as providers (the same keys as AI images), a model, a time limit, and the latest clips with Stop. Agents make clips with video_generate, under the same organisation media rules, daily cap and approval as pictures; clips save beside your pictures with provenance and play in the Library. Not yet run against a live account — tell us what you see.
Roadmap items suggested at plan time. A draft plan shows "Files under: S-2 …" chips from the roadmap (certain on an item id in the text, otherwise a word match a specialist refines), with Add and remove; approving stamps the choice on the plan and its tasks so runs and tokens are counted on the Roadmap. A task's detail has the same chips.
The Foundry design conversation is answered by a specialist, who may only choose from the deployments, models, tools and knowledge connections you can actually pick; anything else is dropped and the question asked again with the choices. If none can answer, the guided interview takes over and says so.
Compute pools have Logs, Pause and Resume, Deploy takes a storage class (with the cluster's classes suggested and the default marked), and a pool reads Ready, Starting or Paused. A pool runs one node — its saved state lives on one volume — so more than one is refused with the reason.
Workflows offer only placements this computer provides; a workflow file that still names a pool or cluster shows a read-only note with "Run on this computer instead". Pre-flight lists the inputs Run will ask for.

0.90.18

The first public release since 0.90.6. 0.90.17 was tagged but never published (one test compared paths the Windows way), so this carries everything listed under 0.90.7 to 0.90.17 below.

0.90.17

Tagged, not published. It carries everything listed under 0.90.7 to 0.90.16 below, and:

Access is an override you can see. In Chat, Research and Team Work, Access starts at "As set" (the agent's or team's own approvals) and a choice applies to this conversation only. When it asks less than usual the message box changes colour and names the level; Full access is shown in red.
Make → An app. Ask for an app and the agent proposes a workbench app you save into Apps — a chart, a tracker, a form or a small game — instead of writing a web page.
Token figures agree. Operations counts tokens and spend from the same records as Token economics and Home.
Status report is a card on the Roadmap, beside the vision and the status counts.
Edit project has one Save for the name, the colour and the purpose.
Deleting a project can remove it from your organisation too, so recreating it no longer leaves duplicates there.
Dropdowns are readable in dark mode again, and the usage card no longer covers the Usage button on a small window.
Memory on Free no longer shows the Every repository view.
Workflows you can build. Opening a workflow that names people who are not on this computer asks who plays each part. Add a step puts it after the selected step, a + on each card or on a branch inserts it there, and Add before / Add after are in the step's panel. Every step has "Write it for me": a named specialist drafts its fields from a sentence, shown as before and after for you to accept. Script steps pick from the repository's scripts, or ask an agent to write one. Run is disabled with the reasons until a workflow can run.
Workflows run end to end. On a project that is yours alone, you can approve a high-impact step yourself (it used to refuse the person who started the run, then hold after four hours). GitHub steps in a run you start by hand work on this repository. The run view shows who is working each step, with a link to its task, and why a step failed.
Compute says why. A load, a check or a removal that fails says what went wrong instead of spinning; "no kubeconfig" reads as "Sign in to a cluster first" with the sign-in lines, the paths it looked in and Check again; an expired sign-in or a missing tool is a sentence with the command to run. Cluster and node-pool placements for workflow steps are labelled "not yet".
Foundry failures in words. Every Foundry action that failed used to leave the screen waiting; now it says what happened, and sign-in refusals are plain words with the next step. The design flow is labelled as the guided set of questions it is; a Prompt Shields option that did nothing is gone.

0.90.16

"Set up for agents" is not offered when everything is already in place. A repository that said yes with nothing left to do counts as set up, even when there was nothing to apply.

0.90.15

A team member runs on the runtime it is set to, or not at all. If that runtime is not installed where the repository runs, the member does not start and says so, instead of running on another one.
One running session per team member. A member whose own copy of the files cannot be made does not start in your checkout; it says why.
A folder inside WSL added as a Windows folder offers to open it on the WSL machine instead.
Memory counts this project's sessions, with "All my projects" as a choice, instead of every project on the machine.
Sign-in is checked where the agents run. Settings says when Claude is signed in on this computer but not in the WSL machine the project uses, with a button to sign in there.
"Set up for agents" stops reappearing after the wizard has set the repository up, and a missing sign-in no longer brings it back.

0.90.14

Risk is said as a level out of five: "Risk level 4 out of 5: needs approval", on approvals, notices, the Inbox and Explore, so nobody looks for five risks.

0.90.13

Explore shows what happened, not just totals. Pick an agent, a tool, a command, a connector, an approval, a hand-over or a file to see its calls or turns, newest first, and go from there: to the turn in the events, the connector's settings, the approval in the Inbox, the other agent's history, or the file in the editor.
Explore's labels keep the meaningful end of a command, and its panel no longer covers the picture.

0.90.12

Timing in a team's or specialist's History no longer flickers. Hovering a step only highlights it; a click picks it, and its details sit in a card that keeps its size.
One scrollbar for the History tab's timing chart, instead of a chart inside a scrolling panel inside a scrolling page.

0.90.11

Agent history is one viewer everywhere. A Team Work session, the History page, a team's History and a specialist's History all open the same history (events, files, timing, filters, downloads and Explore). An archived session opens in the app, not as a raw file.
A team's or specialist's History loads. The request was never answered by the workbench; it is now.
Explore says when there is nothing to explore and is not offered for a history with nothing in it.
Delete a branch with its worktree in one step from the delete dialog, with what would be lost said first.

0.90.10

Merge into main on a branch that conflicts names the files changed on both sides and offers Resolve with an agent, Open in the editor or Cancel. Nothing is written until the conflict is checked, so main is never left half merged.
Deleting a branch is a dialog from its card: it says what would be lost when the branch is not merged, and errors show in the dialog.
The Scribe's description of 24 more areas of the Architecture map.

0.90.9

Designing a Foundry agent in conversation no longer crashes the view.
A team's History always ends in its history, an empty state or a reason, never an endless "Loading timing…".
Choosing projects scales. The team and specialist editors pick projects by search, with the chosen ones as chips, "(this project)" first, and "Only this project".
Claude Code updates. When Claude Code's own updater says it is up to date, the row says so, rather than failed because npm has a newer release its channel has not offered yet.
The team editor's "Side effects" tab is "Approvals".

0.90.8

Risk at a glance. Every approval shows its risk as a five-step meter beside the words; a screen reader says "Risk level 4 out of 5". An approval's notice says who asks, with the command on one line.
Review the architecture runs the checks only. The research council is asked when you press "Ask <council> too", never by opening the review.
No more copies of the same housekeeping task. A machine checks the shared board before filing one, and two copies filed by two machines collapse to one.
A heredoc is not read as commands. Writing a list into a file with cat <<EOF is no longer held as reading secrets.
Memory's Full screen no longer covers Reset view.

0.90.7

Project covers you control. Edit project has a Cover section: upload your own picture, make one with an image model, choose which part shows on Home and on the card, or remove it (with a way back). New generated covers are composed as wide banners, so nothing important is cut off.
The Architecture map loads on large repositories. A repository whose map was too big to send now leaves out the links between symbols and says so, instead of waiting for ever.
Memory has Reset view (or press 0): back to the whole picture, nothing selected, folders closed; your tab, layout and filters stay.
Sign in to Azure works from the Foundry view. The page Microsoft returns to is always listening, and a refusal says in plain words what an administrator must add.
Microsoft Foundry is part of Enterprise. On Free and Teams the Foundry view explains this, and Foundry members and workflow steps stop with the same sentence.
fal and Higgsfield. Clearer errors (an empty balance, a refused key, the content filter, a rate limit), retries while a picture is queued, a timed-out request is cancelled so it is not billed, keys from FAL_KEY and HF_API_KEY_ID/SECRET, and Check for a Higgsfield key.
Compute without a kubeconfig shows each cloud's sign-in command and where it looked, with Check again.
Git History no longer repeats the sync badge Source Control shows; the page's header has the status and its actions.
Interface components updated; Acknowledgements keep a long licence from squeezing its row.

0.90.6

Foundry Studio. A new Foundry view under Automation is one place for Microsoft Foundry: sign in to Azure once, see your subscriptions, Foundry resources and projects with their models and agents, search and filter them, and create a project, a guided new Foundry resource or a model deployment, each shown as a plan before anything is made. Your organisation's approved connections come first, and a project it has not approved yet can be sent for approval.
Design a Foundry agent by answering a few steps or by talking it through with the Designer; both make the same agent, secure by default, and nothing is made until you check it. Adopt an agent built in the Foundry portal as a specialist (it is never rewritten or deleted), see its versions, where it is used and its runs, and use any Foundry agent as a team member or a step in a workflow.
Share Foundry agents with your organisation: publish yours to its catalogue (the instructions never leave your computer), and add, review or withdraw the ones it shares.
Azure Local. Add a Foundry Local on Azure Local endpoint and design agents on its models. A disconnected cluster is reached on your own network only, its usage is counted against the cluster, and one your organisation has not assessed yet says so.
Compute. Add one of your Kubernetes clusters, check what it offers, and deploy a Mojo Up node into it with a plan you confirm first (a Helm chart is included too). On a cluster each agent session runs in its own locked-down pod that can reach only its node; Teams can place a member "On your cluster", and Home shows the agents working there.
Workflows start on their own: on a push, a pull request, an issue, a comment command, a schedule or another workflow ending. New steps get the code, run a command, wait for checks, comment, review, merge and deploy; a merge or a deploy always waits for a person to approve first. Starters: Review every pull request, Fix a failing build, Triage new issues.
GitHub. A team hub can receive GitHub's events ("Connect GitHub"), a workflow can be put into GitHub Actions as a file, on GitHub's runners or on runners in your own cluster, and a job can join your organisation with GitHub's own sign-in instead of a stored key.
Container images for the node and for the agent sandbox, signed, for Docker and Kubernetes; the node also comes for Linux on ARM.
Usage from Microsoft Foundry and the Azure gateway now says which resource and project it came from, so your organisation can tell them apart.

0.90.5

See where an agent's time goes. Agent History has a Timing view: every step of every turn — the model working, each tool call and MCP call, requests through the model proxy, waiting for your approval, the data-protection checks — as a Gantt-style waterfall you can zoom, with the slowest path through each turn marked, time by kind and the slowest tools (calls, typical and worst times). Search and filters (kind, status, member, tool, slower than, a time range) narrow it across a whole conversation, and a turn or a conversation exports for Perfetto or Chrome's trace viewer, as JSON or as CSV. Steps keep names, sizes and times only, never what was written.
History in Teams. Every team and specialist has a History tab: its work across Chat, Research and Team Work, with a summary of turns, time and the slowest tools.
Your usage reaches your organisation. The workbench's repositories sent their usage to your organisation with a token it refused, so its token economics and budgets saw nothing; every call to your organisation now carries your live sign-in, one upload that keeps failing no longer holds back the rest, and the last 90 days catch up. Settings shows when your usage last reached it (token counts and costs, never what you wrote).
No more empty pages while things load. Teams, Roadmap, Apps, Operations, Workflows and Home say what they are loading, or why it failed with Try again, instead of showing the "make your first…" page before the answer comes.
A specialist chooses its picture model. The Diagrammer, the Scribe and any member that makes pictures has "Pictures made with" in its settings; your organisation's picture rules still apply, and a model that is not available says so rather than using another.
No duplicate specialists in your organisation. Setting up on another machine uses the organisation's Diagrammer, Researcher and the like instead of making a second copy; saving one yourself asks whether to use the organisation's.
Fixes in checks look like buttons, like the rest of the app's fixes.
Covers are made in Projects; Home shows the cover and can remove it.
An app too large to follow you (over 512 KB) is said, and stays on this computer. Copies of AIOE 0.78.0's shared files.
Your repository's state at a glance. The Source Control item shows what is waiting, the way VS Code does: ↑ to push, ↓ to pull, • changes not committed yet, and a mark for a diverged branch or a clash; nothing when all is clean. The Git History icon carries the same mark and a card with the branch, what it tracks, when it last checked and the last commit, and every commit in Git History has a card with its message, author, time, branches and tags, files changed and whether it is pushed.
An update never jams on the workbench's own files. The workbench now keeps its ignore entries in git's own local exclude file instead of your .gitignore, and putting your changes back after an update settles a clash in its own files by itself. A repository already stuck that way gets a "Fix it" in Source Control; where your own files clash too, you choose per file, with a copy kept.
Your apps, Home and project covers follow you. Signed in to your organisation, Mojo Up AI Cloud or a team hub, the apps you make and your Home's pins, hides, dock and favourites go with you to every workbench you sign in to, kept privately; a project's new cover shows on your other machines too. (Your organisation's half arrives with its next release.)
Project covers show where you look. A cover banner at the top of the project's Home, with Change and Remove, a proper cover on its card in Projects and a small one in Home's projects strip; after making one the dialog says where it is.
A better box for a picture's own words, three lines that grow, up to 800 characters, with the count in sight.
Set up for agents only where it can work: a stopped repository offers Start instead. Use a local model after all takes effect at once.
The Images test picture can be opened: the last test picture with its time and where it is kept, Open full size and Show in folder.
Purview checks no longer run out of time before they are sent. The time your organisation allows is the check's own, held settings decide at once, and a check that timed out on this machine is asked once more.
Copies of AIOE 0.77.0's shared files.

0.90.3

Held actions answer as soon as a person decides. When your organisation tells the workbench a held request was approved, declined or lapsed, the agent hears at once instead of at its next check. A request that carried a file is sent again exactly as it was, and an approval spent on an action that was then refused says so and is never sent again.
Newer organisation hints never cause a full refresh. A change the organisation announces that this version does not know yet is passed over, rather than making the workbench read everything again.
Taking GitHub's version always works. In Source Control, "Take GitHub's version" did nothing when you had no commits of your own; it now asks and does it. And when only your changes not committed yet stand in the way of an update, the bar offers "Set my changes aside and update" instead of rebase or merge choices that did not apply.

0.90.2

An agent's high-impact request waits for a person. When your organisation holds an agent's request for approval, the agent says it is waiting for a person in your organisation's Inbox or on their phone, the Workbench checks back, and once approved sends exactly that request once; a decline is final. Mission Control and the workflow run view show it waiting, and a wait survives a restart.
Why your organisation refused an agent, in words: an agent it does not know, a team not tied to this computer or node, or a role that does not allow it, each with what to do.
A workflow run's report is never left behind. A run that changed while it was being reported is reported again in its newer state, so your organisation and hub never show a finished run as still running.
Follow and drive a session from the console and your phone. Each file a turn changed opens its diff there; a usage limit shows the backend's own words (masked) and the model; you can hand a session to another signed-in account on the same tool; and a session's buttons and forms can be answered there, checked by data protection exactly as a typed message is.
A project's purpose in one line. An owner writes it in Settings › Project or the project's page (up to 240 characters); everyone sees it on the project and its card, with the roadmap's purpose shown until an owner writes one.
No more flashing console windows from a node on Windows, and far fewer background programs. Every program the Workbench starts is told to stay hidden, and a node remembers what it found about installed tools and the GPU for a few minutes instead of asking again on every change (626 programs in 90 seconds became 165, and 8 once it settled).
Accounts on your other machines. A machine now lists the signed-in accounts kept on its WSL, dev-container and SSH targets as well (names only), so a session can be handed to one of them.
The Inference pane shows every model the Workbench uses: what draws your pictures and where, the model that finds memory by meaning, and who answers Ask AI in the editor, on this computer or in the cloud.
AMD Radeon on Windows uses its GPU, with ROCm if you want it. The ROCm builds need AMD's ROCm libraries, which Windows does not have, so pictures failed and text models quietly ran on the processor. Now Automatic uses the Vulkan build, which drives the Radeon; choose ROCm and Settings › Local models offers AMD's ROCm libraries for your card (about 250 MB, from AMD), checks the GPU is really in use before switching, and says why when it is not. A picture no longer refuses a ROCm choice.
A node keeps diffs to the conversation you are in. From the console or your phone, a node shows only the changes of a turn in your own conversation.
An app always loads. Opening an app on a repository whose workbench was not running left it waiting for good; now it starts that workbench, says so while it starts, and says why with Try again if it cannot.
Getting started on Home. New here? Home lists what is left to set up, each step one button away and ticked off as it happens; hide it and bring it back from Help.
Try these. Seven things to try from Home, each opening ready to read and nothing sent until you send it: have one member lead another, a morning summary of every open task, a small app, research with several viewpoints, the Scribe or the Diagrammer on how your repository works, and a specialist reviewing your pull requests.
Fixes from a review of 0.90. Workflows: four-eyes approval also holds for a run started by a routine or an event; a run left queued by a restart starts when it resumes; an approval's deadline wins over a late decision; a code step's write never lands in .git or .mojoup. Roles: an agent's permissions are read again after a roles change, and an unknown grant no longer switches roles off. Usage: a call at the edge of a range is counted once. Git: taking the remote's version discards nothing when the commits cannot be counted.
New user guides for workflows, the Overview, token economics, roles and permissions, live sessions, project architecture and self-updating nodes.

0.90.1

A rebase that is still running shows its progress. Putting your commits on top of a remote's shows "… 3 of 12" while git works, with the branch "being brought up to date"; Continue and Abort appear only when it has really stopped, naming the files, and the project.json notice is never offered mid-rebase or for a change already committed.
Your organisation's refusals in plain words. When new projects are registered by administrators, the project keeps working here and you can copy a request to one; actions that only the console can do link to it; a removal that needs a fresh sign-in asks for one and tries again. The Workbench says up front when your organisation would refuse a new project.
A policy setting the Workbench cannot read is left out on its own, named in Settings, while the rest of your organisation's policy applies; the workflows switch from AIOE 0.74.0 ("on"/"off") is read.
Every agent has a lasting identity. Each team member gets a stable id that survives a rename, so its history, usage and organisation roles stay with it; calls made for an agent say which agent, for which person, in which team and run; the Workbench asks your organisation what each agent may do and refuses before calling, and an agents.highImpact policy list (which can be lengthened, never emptied) decides which agent actions wait for a person.
Nodes keep themselves up to date. A node now installs a new version by itself (the setting was "notify"), waiting until no agent is at work and no approval is pending; an organisation or person can still choose notify or off, and the console's update switch works again.
Operations points to Token economics for spend and tokens instead of repeating them; the Git History panel waits while a rebase runs; a repository on a team hub reaches the hub's apps and routines; workflow steps name their agent by its lasting identity; your permissions refresh the moment your organisation changes a role.

0.90.0

Workflows. Draw a workflow from agent steps, proven code steps and approvals, with branches, parallel steps and joins, and watch it run step by step. An agent step is worked by the specialist or team member it names through the board; an approval waits in the Inbox (and on your phone) with Approve, Reject and Hold, asks why before Reject and Hold, and a high-impact one asks for your sign-in, Windows Hello, Touch ID or your Linux password first. Steps can work in any repository of the project, or across projects. Start a workflow by hand, on a routine, when something happens, from a team's planner, or from your organisation's Run now. Runs are reported to the project's home and can be cancelled wherever their steps run. The security incident response template is included.
A catalogue of workflows, like apps. Publish a workflow to your team's hub or your organisation (listed at once, reviewed first, or off); anything that names a machine's specialist, member, team, repository or project becomes a question asked when someone adds it. Add one on another machine, keep it in the repository or as yours, and update it when a newer version is listed. A workflows policy decides whether workflows run, publish and run scripts.
Agent and team Overview. Every team and specialist opens on an Overview: what it is for, a time range, when it works (a heatmap of model calls by weekday and hour), completion, open tasks, model spend and cost per task, run success against a 95% target with its error-budget burn, and what is waiting for you. With an organisation the numbers are its own, filled from this computer where it has none. Team settings are in tabs, with the planner and member order on Agents.
Token economics. A view of spend, tokens, calls and cache efficiency over time, allocation by team, source and kind of work, and the highest spend by agent, job and person, sliced by team, specialist, project, repository or session; your organisation's numbers when you may read them.
Roles and permissions. When your organisation turns roles on, what you see and can do follows them, agents never act beyond Member or beyond the person they act for, and their high-impact actions wait for a person. Settings › Organisation shows your roles in plain words.
No more command prompt windows on Windows. Every program the Workbench, its node and its hosts start opens hidden.
Project architecture across its repositories. Asking for a project's architecture or a project picture starts any repository that is not running, shows which repositories' architecture is current, out of date or missing, has each one's Scribe bring it up to date once you confirm, redraws the project's architecture, then draws the picture. A question raised on a node reaches your Inbox, phone and the node's dashboard, and takes the safe choice after 30 minutes.
A repository that commits the organisation's policy file is left alone: the Workbench stops rewriting it, says so in Settings, never commits it, and leaving an organisation keeps it.

0.89.31

Catching up a branch with files in the way. When your branch and its remote have both moved and a file you never committed has the same name as one coming in, Put my commits on top, Merge them in and Take the remote's version now name the file first, move it aside (kept under .git/mojoup-set-aside, never deleted), and say afterwards where it is and whether it differs. Every Source Control bar shows the answer to the button you pressed, never an older message.
The Mac app is signed and notarised. The release makes its own signing keychain, checks the App Store Connect details before the build, and falls back to an ad-hoc signature with the reason named rather than failing.
Pictures with a local model work offline. A picture drawn on this computer no longer goes to your organisation's checks or budgets, and a project's cover made with no network is kept on this computer and sent when you are back online.
The right picture engine, every time. On Automatic the image runner only starts a build that can run here (never a ROCm build without ROCm) and fetches the right one first; if you chose ROCm or CUDA and it cannot start, it says why with Use Automatic instead.
Pictures on the Windows GPU from WSL. With the model service on Windows, a WSL repository's pictures are drawn there (Vulkan on AMD and Intel, CUDA on NVIDIA), like its chat and memory models. Download the image engine and model again in Settings › Local models › Images.
The live monitor shows the memory and image models working and their totals.

0.89.30

Ask AI where you write. In the editor and in a Library document, press Ctrl+K (⌘K on a Mac) or Ask, and say what you want: "create a function that parses ISO dates", "draft a paragraph about our release process", "make this shorter", "fix this". The answer appears as a change you can see; Enter or Tab accepts it, Esc rejects it, and you can try again or follow up. On a selection, one click explains, fixes, adds comments, improves the writing, shortens it or fixes the grammar. Your chat model answers, or only a model on this computer if you choose; it follows your organisation's policy and data protection, is counted in Usage under Editor, and every accepted change is audited. A guide in the editor and the Library, and a page on the docs site, explain it. The grey suggestions as you type now show too; they never did before.
The Library edits in the same editor as code. A document's source opens in the built-in editor, with the same keys, undo and Ask AI.
Back up & restore, done properly. One line says when the last backup was, when the next is, how many are kept, how big, whether encrypted and whether your organisation holds a copy. Back up now shows its progress and can be cancelled. Your backups are listed: open one to see what it holds, restore from it, keep it for good or delete it. Restore goes in steps: choose everything, one project, one repository's conversations or settings only, see what will change, and a safety copy of how things are now is made first. A backup can be checked without restoring it, and the newest is checked every week. Ready to recover lists what you need to get back on a new computer. Failures say what went wrong and what to do. Home shows a line only when something needs you, and the tray shows how backups stand.
Clearer words when your organisation needs a fresh sign-in. Organisation recovery and letting a node run your work now say what to do when your organisation asks for it: turn on Bind tokens to this device and sign in again, or sign in again to use your administrator rights on this computer.
A team's member order stays as you set it. Reordering a team's members here now reaches your organisation instead of being put back by the next sync; a reorder in the console comes here, and when both changed, the console's order stands and you are told.
The Mac app is signed with Mojo Up's Developer ID and notarised. 0.89.29's Mac build was still ad-hoc signed because the build could not see the signing keys.

0.89.29

Finding by meaning works from WSL again. With only the memory model running on this computer's model service, a repository in WSL was given it without its key, so every read was refused and finding by meaning stopped at 0 of its items. It now reads with the key.
Pictures on Linux and in WSL. The picture program's Linux build lost its library links when it was unpacked, so it could not start ("file too short"). Builds now unpack whole, and one unpacked before is repaired the next time it runs.
ROCm only where AMD's runtime is installed. On Linux a ROCm build needs AMD's ROCm runtime installed on the system. Where it is not (WSL, usually), choosing ROCm now does what Automatic would and says why, and a missing GPU runtime is named rather than blamed on the download.
Secrets kept by your organisation can be added again. Yours, This project and This repository were refused because the organisation takes a new or changed secret only from you signed in yourself, not from this computer. Adding, changing, rotating and removing one now uses your own Microsoft sign-in, asking for it in the browser once per start when it is not already there.
Codex in WSL. WSL also sees the programs installed on Windows, so a Codex installed with npm on Windows answered codex in WSL and could not start there. A WSL project now uses only its own copy: Codex reads as not installed until it is, and Sign in on a WSL machine installs it there first.
Pictures from fal and Higgsfield. Add your fal key, or your Higgsfield key ID and secret, in Settings › Models, and choose either in the AI images settings: fal brings FLUX, Recraft, Ideogram, Nano Banana and Qwen-Image, with fal's prices shown; Higgsfield brings Soul. Both follow the same policy, data protection, daily cap and budget as the other providers.
The Usage pane says each thing once. One card per account, with its limits, today's use and where the numbers came from; the same Claude account signed in under two names is one card; runtimes not used today are one line. When Anthropic asks the workbench to wait, the last reading stays with its time instead of "Anthropic answered 429", and every window and project now share one question per account, so it is asked far less often.
The editor says what suggests. A chip in the editor's toolbar names the model that suggests code as you type, or says why nothing can and opens Local models.
A model's log opens in a window. Log on a model in Settings › Local models opens in front of the page, scrolled to the newest lines, with Copy.
A dock you arrange. Customise the dock lets you move every place on it (drag, arrows or the keyboard), hide any of them and show them again, and Reset the dock puts them back; Apps stays first. Up to 24 apps can be pinned, and what does not fit goes behind the overflow button. A pinned app's card stays open while you move into it, says what Favourite and Unpin do, and has Name, icon and colour for your own apps. The dock's menu no longer has a duplicate Open the apps drawer.
The Apps page by keyboard. Arrow keys move between apps in every layout and section, Enter opens one, F makes it a favourite and P pins it. Favourites have their own section at the top, so starring an app no longer just shuffles the list.

0.89.28

Ask for an exception only where it can be answered. Where your organisation does not take exception requests, Ask for an exception is not offered beside a refusal or in the Inbox, and asking says so instead of sending.
Declining an exception asks why. An administrator's Decline in the Inbox opens a short dialog for the reason, which the person who asked reads; before, the organisation refused a decline without one. The dialog's words now say what is declined: an exception, a memory proposal or a catalogue submission.
Routines your organisation starts reach only the machines that hold them. This computer and each node tell your organisation which of its published routines they hold that may be started on an event, so a forwarded event goes only where one is held.

0.89.27

Catch a branch up, whatever is on it. When your branch and GitHub's have both moved on, Put my commits on top and Merge them in now work with changes not yet committed: they are set aside while the branch catches up and put back after. A clash stops the catch-up part-way with the files named, and Continue or Abort, never half done and unexplained. A third way, Take GitHub's version, asks first, names the commits it would discard and keeps them on a backup branch. Any other refusal is said in plain words and in git's own.
How teams, specialists and the task board work. The team and specialist pages open with a guide to what members run on and who pays, people on a team, instructions, the operations manager, who answers what and handing work on; the new team and specialist wizard has a short note at each choice with Learn more. The Tasks view's guide explains boards, columns, dependencies, review, merging, people's tasks, trackers and plans. Both have pages on the docs site.
Memory's and pictures' models, findable. Settings › Local models has a Memory and search tab (it was System 1 models) that lists the models memory uses, what uses each, its size and whether it runs, with Start, Stop, Log and Delete, even with no project open; the On device list shows them too, under Used by memory and Used for pictures. Memory's Finding by meaning links straight to its model.
Graphify stays upgraded. Every button that updates the memory engine says which version it installs and none takes it back to an older one; every repository sharing the engine shows the new version at once.
Finding by meaning never sits at 0. Reading items either moves or stops with the reason and Try again, and the reason is written to the log.
Smaller fixes. Dropdown lists are readable in light mode. The log is no longer filled every five seconds asking the local model service what routines watch. Each "Shows on" choice for an app says what that place does. A link to a card in Settings lands on that card, and the Inference gateways' providers can be searched like the runtimes.

0.89.26

Apps can read more, and say what they need first. An app can read the pipelines of other repositories with your own GitHub or Azure DevOps sign-in, and can use a key you keep in Settings › Secrets with an address you allowed (the key never reaches the app's page, the log or the audit trail; the statement names it, and adding one asks again). Before an app works, its card and its screen list what is missing — a sign-in, a key, a connector, a repository you cannot read — and where to fix it. An app that names a tool server this computer does not have is refused at Save, with the ones you can use, instead of being saved and never working; the specialist who builds it is told what is here, finds out where the data really comes from, and asks rather than guesses.
Name, icon and colour. Your own apps and the repository's have Name, icon and colour… on their menu, so two apps no longer wear the same rocket.
Ask the Scribe opens the conversation. Making or changing an app takes you into the conversation the specialist works in, instead of an empty new chat.
Pin a default in Research and Team Work. As in Chat, pin a specialist or a team in Research, or a team in Team Work, and new conversations start with it.
Every release on the docs site. What's new, Documentation and Report an Issue open the public docs site, which now has every release's notes.

0.89.25

Your date and time choices follow you. Set the clock, the date order and the first day of the week once, and the organisation's console and your phone read times the same way; a desktop still on Follow system takes the choice from your profile when it signs in. Needs AIOE 0.71.0 or later.
Costs and design systems use your date format too. The month names on cost reports and the export date of a design system follow Settings › General › Date and time.

0.89.24

Work is checked once it comes together. Before work that combines several tasks merges, the repository's own tests, lint and type checks run on it; a failure holds the merge and goes back as a fix task to the member whose merge turned it red. A red CI run or pull-request check on a task's work goes back to its member too, at most twice (pipelines.fixCycles), then to you. Agents may not make a check pass by skipping or weakening tests: such a change is flagged to the reviewer and in the pull request.
Each task tells the next what it did. A task that depends on another gets a short handover: what it built and changed, what review asked for that was not done, its known gaps, and what will not arrive if it was cancelled. Lessons a plan's members record reach the plan's later tasks, and two tasks running at the same time that change the same files are named on the plan.
A stuck task comes with a proposal. After the review rounds and a stronger attempt, the operations manager says what kind of failure it is and proposes another approach, a split, accepting it with listed gaps, a change to the rest of the plan, or stopping. You decide in the Inbox, or let your team take the recommendation. A failed acceptance criterion gets fix tasks before the plan asks you to accept it.
Routines can start on an event. Besides a schedule, a routine can start when a pipeline fails, an issue gets a label, a review is asked of you, changes are requested, or a node's workbench stops; with your organisation (AIOE), from an outside webhook too.
Ask for an exception. Where your organisation's policy refuses a model, a runtime, a tool server or an address, ask for an exception right there; the answer comes back where you were refused and in your Inbox.
On a Mac. Claude Code's sign-in is recognised (it lives in the Keychain), so teams can be made on your default profile; the memory engine gets its own Python 3.12 when the Mac's is too old, and its setup panel scrolls; the workbench no longer looks into Desktop, Documents or cloud drives; local models clear macOS's quarantine flag and say exactly why one stopped; each local model has its own Start, Stop and Log; a cover keeps waiting while the image model draws; nothing pops up over first start; install buttons match; and window titles clear the window buttons.
Smaller fixes. A task marker run straight on into the next word is still recognised. After a differently signed Mac build, the app says plainly that it cannot read what it saved and offers to start afresh.

0.89.23

Nodes keep working overnight. Connecting to a node your organisation assigns you no longer needs a recent sign-in, so a repository on a node reconnects after sleep or a restart on its own. A recent sign-in is asked for only when you change something on a node: adding a repository, its routines, its update or its local model. Settings › Organisation says until when changes on nodes need no sign-in. This needs AIOE 0.70.0; until then the organisation's rules stand as they are.
Rename an app. Your own apps and the repository's have Rename… on their menu. Pins, their place on Home and what they show stay as they are; a repository's app gets its new name in its file, which you commit so everyone who works there sees it.
Add specialists all at once or one by one. First start gains a Deploy tick on each specialist, so you can leave one out. Settings › Setup gains Add all beside each card's Add.
Make a cover never hangs. It used to stay on "Checking what this workbench may use…" when the check took longer than ten seconds. The workbench now always answers, and the dialog offers Try again if it hears nothing.

0.89.22

No more "Sign in again" every hour for your node. Only something you start on a node can ask you to sign in again: adding a repository there, or changing its routines, its update or its local model. Background checks of its status, ports and routines, and reconnects, never do. Once your organisation runs AIOE 0.70.0, attaching to a node needs a sign-in from the last 12 hours instead of the last hour, and Settings › Organisation shows the two windows apart: until when you can attach to nodes, and until when you can take control of a computer.
Pause all shows on the console and your phone. A Team Work run's live view says when its board is paused, and a reload shows Resume all.
Smaller fixes. Dropdowns are readable in dark mode. An app proposed to show in conversations says how: type / in Chat, Research or Team Work and pick it.

0.89.21

Your live sessions, properly, on the console and your phone. A plan's wrap-up, a question asked of you, a hand-off and the outcome report arrive as what they are, not as plain text. Answer a question put to you from your phone. An approval shows the command, the file or the change it is about; a tool call says what it did; Team Work replies name who is speaking; a usage limit shows as a wait with when it lifts; a finished reply lists the files it changed; and Pause all / Resume all work from the console. Stop works on every Chat, Research and Team Work conversation.
Your organisation's own provider assessments apply here. An organisation can rate a provider by the address it calls and the model as well as by name, and add providers of its own. The most specific rating wins, a provider it does not allow is refused in words that name its assessment, and Settings says when an assessment is due for review.
Smaller fixes. A plan wrapped up before October no longer shows as under way. A request the workbench answered itself is never shown on your phone as waiting for you. Check this team also finds the agent identities a team still holds for people who have left.

0.89.20

People in Team Work. Type @ to name a person on the team as well as an agent; they are told, and the name shows as a chip. Mentions filter the session list, and Next mention / Previous jump between the ones that name you; opening a mention from the Inbox, Home or your phone lands on the message. Agents can ask a named person a question, which you answer right on its card. The session says who steers it: the person who started it and the people they choose steer, everyone else replies, and agents read a reply as a teammate's words. Set yourself away until a date with a note, and agents see it.
Who answers what. A team's rules for who answers which topic, who covers whom while they are away, and how long is reasonable to wait. Agents decide from them whether to wait or ask someone else, and say what they did; nobody is asked on a timer. Edit them in the team editor; the team's card sums them up.
Check this team. One action on each team checks it here and at your organisation: whether each member's runtime is installed and signed in, its model server running and the model on it, its keys present, and whether a member pinned to another machine can be reached. Each finding has a one-tap fix. Teams that need attention are marked, with a count on Teams.
Members on your own model server stay yours. A member that runs on LM Studio, Ollama or another local server on your machine is saved as yours. On a teammate's workbench it reads "LM Studio on mju-jp-dev", with "Use this machine's instead", and it is never quietly run against their local server.
Your organisation knows which app did what. Every request names the app, its version and the system, so the audit trail reads "AI Workbench 0.89.20 on Windows". The Sentinel template declares the new columns.
People in Team Work, Check this team at the organisation and the attention marks work with Mojo Up AI Cloud today; an organisation running its own AIOE needs 0.67.0 or later, and until then the checks on this machine still work.

0.89.19

Your phone and your organisation's console, properly. Home on the phone connects first time. You can watch your workbench's screen from the console or the phone, and drive it after a fresh sign-in, behind your own Screen sharing switches. Settings › Security has a new "What your phone and console can do here" panel: one row per thing (Home, approvals, messages, terminals, watching, controlling), what stops it and the fix on the row — Turn on, Allow, or Ask to allow, which sends the request to your phone or the console for you to approve. A phone paired through Mojo Up needs no Tailscale; direct pairing is folded away for workbenches without an organisation.
A node console. A shell on a node from the organisation's console or the phone — no keys, no open ports. Off until the node turns it on, never as root unless allowed, at most two at once, closed after 30 minutes idle, and recorded by who and how long, never what was typed.
One Home. All your projects or one, chosen with a filter row; the feed in Feed, List or Board view; approve, answer or install right on a card; Clear one card or Clear all, with Undo and a "Cleared · Show" list to bring any back. The dock stays on one row, with an overflow for the rest, and Home has one Ask. Make a cover now lives in Projects.
Conversations name things. Plans and tasks are called by their names ("PLAN-3 · Create the live-check file"), the working strip reads properly, and "your phone" is never "You's phone". When nothing can run a council or a team, a guided card sets one up. Critique starts on for a Specialist and off for a Team or a Council.
Teams. Changing a member's model in an organisation project now takes — a member switched from a local model no longer keeps pointing at it. A member that could not start says which one and what to change, once. The agents pane no longer flickers, a member between tasks shows as resting, and every cost shows in your currency.
Plans wrap up at your organisation. A plan's wrap-up reaches the console, stays there until the plan is finished, and what someone asks of it there is carried out here.
Settings. Search finds any setting from any page and takes you to its row. Date and time formats: a 12- or 24-hour clock, the date order and the first day of the week, everywhere. Menus match the size of their field.
Smaller fixes. Maps in apps load. The apps drawer closes when you switch areas. A test build is never offered an older version, and a real downgrade says so. A repository that stops answering no longer holds your phone's or console's requests open. The sidebar scrolls on a short window and says what is below.

0.89.18

Apps, finished. "Instruments" are Apps again. An app can be built from 120 controls — every kind of chart (area, bar, line, pie, radar, radial, scatter and bubble, histogram, box plot, funnel, treemap, heatmap, sankey, gauge, sparkline, waterfall, stacked and dual-axis), a full data grid (sort, filter, group, pinned and resizable columns, bulk actions, CSV), a map, steppers, tabs, date and time pickers, sliders, rich text and more — or from a custom view its agent writes in HTML, run in a locked-down frame that reaches only what the app declares. Apps read from the Workbench, from a read-only tool your policy allows, or from a web address you or your organisation approve. Making an app opens Chat with a starter sentence; the proposal shows a live preview you can adjust before saving, and changing an app's look now updates it everywhere. The drafting agent cannot run commands or edit files. The Apps page has Cards, Feed (live previews) and List views, favourites, search and filters; Delete; the drawer lists every app; the dock can be customised, and hovering a pinned app shows a card with its preview and actions. A "Controls" gallery shows every control live.
Apps are governed. Each app version states what it reads (with the highest sensitivity label), every external source and whether anything leaves the Workbench. Saving or adding it is your consent; you are asked again only when a new version reaches further, and an app your organisation approved is not asked about at all. Your organisation can allow external data only in approved apps, list the connectors and addresses apps may use, cap the label an app may read and stop data being sent out. A label chip and an "External data" chip show wherever an app appears.
Routines in the catalogue. Publish a routine to your team or organisation (the dialog shows exactly what is shared and flags secrets, paths, emails and names), add one from the catalogue with a few questions, update to a newer version, review and withdraw — under the organisation's policy. Nodes can add catalogue routines for their members.
Plans wrap up in visible steps — check what shipped, verify the criteria, settle follow-ups, review and merge, close — in Plans, in the conversation that launched the plan, on agent cards and on Home. Review all changes is a real review: a file tree, one file at a time with colour, no row limit, notes to the agent and Mark reviewed.
Conversations read better. Each step of an agent's turn is its own paragraph beside its tool row; test results, tables, file lists and checklists are drawn as rich blocks (a setting, and a policy, can turn that off); a strip above the composer always says who is working on what, with Jump to the latest and Stop. A message typed mid-turn reaches a Claude Code agent during its turn.
Agents live in the right-hand pane. The title bar's agents chip is gone; the pane shows a rich card per agent — state, what it is doing, task, context, spend, its approvals inline — and grows to show its last steps.
Ports, like an editor's. The Workbench's own services are named and grouped apart from yours; dev servers such as Vite are recognised (with a toast when an agent starts one); forward any port, label it, choose who can reach it (this computer or your network), auto-forward an agent's ports; WSL networking is explained; connected nodes are listed too.
Views with feeds. Projects, Operations, Decisions and Source Control share one feed card with filters, sort, pin and hide. Source Control cleans up stale worktrees and opens the same review as a plan.
Terminal. One New button: shells for every place your repositories run, only the agent CLIs switched on in Settings › Runtimes, and team members; a tab menu holds the rest.
Usage limits wait, never error, and a limit files one Inbox item with Hand off to another account or runtime. A runtime switched off in Settings › Runtimes no longer starts members, and says so with "Turn it on".
Smaller fixes. Memory: Circle is gone (it was Hex), the folded Find and Details panels are small buttons, Shelves' connection lines are drawn reliably. One explainer per page. The default model can be set in Settings › Runtimes. Agent CLIs install inside a dev container. Nodes no longer re-run repository set-up every few seconds.
For your organisation's servers. Memory now syncs only what changed (a typical edit: one small request instead of about 2 MB), compresses what it sends and listens for change notices instead of polling. The phone can open apps and gets plan usage as numbers.
Obsidian vault export. If you exported your organisation's memory to a vault before your organisation's server moves to AIOE 0.65.0, run the export again after that update: an older server could leave a few items out at page boundaries.
macOS. The app is signed so macOS offers Open Anyway on first open instead of calling it damaged; full signing and notarisation follow once Apple approves Mojo Up's developer account.

0.89.17

A message typed while an agent works no longer stops it. Chat, Research and Team Work used to cancel the turn in flight ("Interrupted Hannah") and lose the work. Now the agent keeps working, your words reach it with a note that they arrived mid-turn so it folds them in, and the conversation says so. Only Stop interrupts.
A usage limit is a wait, never an error. A member at its plan's limit reads "Waiting for its limit · lifts 11:40" in warning colour on every surface (Mission Control, chips, cards, Office, Operations, Home, the node), with a countdown, and Hand off to…: another named account of the same runtime, or another runtime and model, for the rest of the session, audited. The member editor's "At its limit" row makes that automatic. Not yet: an Inbox record for a limit.
Approvals explained. "Risk 3 of 5: needs a look" now has "What does this mean?": the five levels in words, what this one covers, what your conversation's mode does with it, and for levels 1 to 3 Stop asking at this level and approve, which switches the conversation to Full access (4 and 5 always wait for an owner; the organisation's policy may cap it). A phone or the console is told up front when only the desktop may approve, instead of a button that fails; an organisation can decide per person what a phone may approve (AIOE 0.64.0).
Make an app never spawns an agent of its own. A repository not set up for agents stops at the offer; otherwise the Scribe takes it, or the specialist picker asks. The set-up offer snoozes ("Not now, ask again tomorrow") and leaves a way back in the Inbox, a strip in Chat and the Commands palette. Mission Control has Stop agent beside Restart.
Runtimes, one list. Settings → Runtimes shows every runtime, built in or from the catalogue, with the same row, state chip, Details and switch; pickers list the enabled ones with "N more are not turned on". Not yet: switching a catalogue CLI off does not stop a member already configured on it.
Source Control cleans up worktrees. A Worktrees section with size, age, state and who made it; Clean up stale lists what would go and why, never touches a tree in use, locked, dirty or just made, deletes the merged branch with the tree, and audits each removal; an optional per-machine sweep on start.
Ports as a table, VS Code style: Port, Address, Process, Origin (the agent or terminal that opened it), Mine/All, search, keyboard, row actions. Not yet: the Workbench's own services named, dev servers recognised, labels, LAN visibility and the WSL notes — that round is in progress.
Home's Working-now cards say "PLAN-7 · objective" and what you asked, never a raw plan id or the hand-off heading.
The Linear mirror's tests depended on a fixed fake date and failed as the day moved on; fixed. The phone's /ws/ticket answers 503 when channels are off. OpenUI is credited in Acknowledgements. A release-tracking app that had been built into the Workbench was taken out; the generic steps block it added stays for apps and agents.
Known gaps, being finished for the next release: apps ("microapps") — the rename, Delete, the drawer listing every app, a configurable dock, a starter sentence with a live preview and Adjust, and a drafting agent with no shell; conversation readability (each step of a turn on its own, rich blocks drawn from what agents write, a pinned working strip); plan wrap-up as visible steps.

0.89.16

Agents can draw a form, and apps live on Home. An agent's answer may carry a UI block — choice cards, fields, a table with row actions, stats, buttons — drawn by the app with its own components from a validated, declarative description; no code from a model ever runs. Pressing it answers the agent with a structured message. The same block works in Chat, Research and Team Work, and agents get ui_schema and ui_render. A microapp is such a description with a manifest: what it reads (Control API reads, within the scopes the device may grant and under the DLP floor), what it may do (declared actions run as you and audited with the app's id and version), and where it shows — a Home feed card, a board tile, full screen with an About pane, a dock pin, or /app in a conversation. Apps live with you, in a repository's .mojoup/apps/, or in the project's home: Publish to the team / organisation sends a versioned, hashed app with the author by name; the organisation's microapps policy decides whether it lists at once, needs an owner's review (an Inbox item) or is off, which scopes an app may ask for, and whether apps may write. The project's new Apps page lists own, team and organisation apps with Add to Home and Make one like it; "Make an app" asks the Scribe, who proposes and you save. The dock's first item is Apps: a drawer (Ctrl+Shift+A) of your apps and everything in the Workbench, with pins dragged to the dock. Three example apps ship: Release board, Spend this week, Open pull requests. Feed and dock preferences now live on the host, so a phone's press and the desktop's pins agree.
System 1 models, phase 2. A small sidecar downloaded on first use (pinned and digest-checked; not for Intel Macs) runs classifiers: a prompt-injection guard scores every tool result an agent brings back from outside the repository and wraps the suspicious ones with a one-line warning — never blocked silently, always audited — under the guard.toolResults policy; a first-pass sensitivity classifier speeds up the DLP check with regex spans for the exact secrets; Ask on Home offers "Open it in Team Work" when a message reads like a plan. The "System 1 models" tab shows the sidecar and each model.
Linear as a task tracker. Beside GitHub Issues and Azure Boards: the board's columns map to Linear's workflow state types (confirmed once per team), two-way sync with one writer per item, comments both ways, labels and assignees by name, rate limits honoured. A pasted API key, kept in the secret store.
A "By work" sidebar. The sidebar's head switches between Views and By work: what is in flight — conversations, unfinished plans, held tasks — grouped Needs you / Running / Waiting / Recent with who and where. Quick open understands #123, PR 123, T-42 and PLAN-7; Settings → Help gains a Keyboard shortcuts page; a merge in conflict offers Resolve with an agent; a finished plan offers Review all changes with the note composer; the force push says what it does in plain words; element captures carry the source file and line.
Runtimes, finished. A terminal-kind CLI can be a Chat specialist (its reply read from its terminal, said as such); a Windows node without a pseudo-terminal runs terminal members on pipes and says so; the node's runtimes screens show update answers; Codex plan windows fall back to the newest sessions file when the app-server is quiet; named accounts for Mistral Vibe, CodeBuddy and Kimi Code.

0.89.15

Review notes on lines. In a task's, a turn's or a file-changes diff, press a line (or drag a range) to leave a note; notes are drafts per branch until you send them all at once to the agent working that branch — one message, grouped by file with path:line, which the agent answers as done or skipped per note so each shows resolved or open. With no agent running the notes attach to your next prompt ("3 notes attached"). On a pull request the same notes post as one review comment.
Ports and the connection chip. A Ports panel lists the ports an agent or a terminal opens inside a target (this machine, a WSL distro, a dev container, an SSH host): program, target, reachable or not, Forward, Open in the browser, Copy address; agents get ports_list and ports_forward (audited). The title bar's target pill says when the link is reconnecting, lost (and why: "Ubuntu-26.04 is not running", "the container exited", "SSH timed out") or back, with Reconnect and Open the terminal here.
The mojoup CLI for agents. A team member gets its own control token at spawn — its own task, its team's board, memory, plans and pipelines, never settings, git, permissions or terminals — and a built-in skill that teaches mojoup task show| update|comment, mojoup memory query, mojoup board list, mojoup plan status, mojoup pipelines status. Every call is audited as the member; the token dies with the session.
Install channels. Homebrew (a cask for the app, a formula for mojoup-node), winget and the AUR are generated from each release's digests and submitted by the release workflow once their secrets are set; the README gains screenshots and the install lines.
Phone and tablet. companion.home serves the same Home (strip, stats, feed) to the companion app with useful / not useful / pin / hide coming back; Settings → Security gains Pair a phone or tablet with a QR code, the scopes the phone gets (terminals opt-in) and the paired phones with Revoke; a terminal tab can be put under Control from the phone; a phone on the same network talks to the workbench directly over a WebSocket, only over the tailnet certificate; a team hub gives a phone one overview across the person's machines.

0.89.14

Memory is one control, and it scales. The Globe is now the Universe. Every picture — Universe, Map (Rings, Force, Circle, Hex and Shelves), Timeline — shows groups with their counts at rest and opens a group on press: the other rings compress into a rim that keeps their names, the group's children fill a wide inner ring in named arcs (a phase by status, a topic's folders by count, a folder's files), any level deep, with a breadcrumb, Back and Escape. Topics are capped at twelve plus "Other topics"; only the biggest names show at rest. The card lists connections you can follow — point to light the link, press to fly there. Shelves draw the selected chip's connections. "View here" answers in words when a file cannot be read. The picture is never covered: one toolbar row, Find and Details as columns or rails on a narrower window, the breadcrumb and legend inside the stage. Memory no longer reloads every few seconds.
Memory setup is a guide again. Set up (header, in every mode and scope; the More menu; the Find panel; the palette) opens the step-by-step guide: the engine, the first build, what is read, the rules, kept current, finding by meaning (what it is, what you get, what you lose without it, where it runs — the local model, a hosted provider for items at internal or below, or finding by words), browse by topic, and on a team or organisation project sharing: the project's knowledge is mirrored into the team's or organisation's memory by default, with the switch as the way back and the organisation's memory.mirroring policy deciding (on, off or the person's choice). Find has an "in Everything / Code / Knowledge / Project" choice and "Trace a connection…"; a question asked from Home opens here on its answer.
System 1 models. A model has a kind (generate, embed, rerank, classify, vision, speech, world); one service serves embed and rerank behind the bundled runner, Ollama, LM Studio or the gateway, under one rule: nothing above internal leaves the machine. A self-tested reranker puts Find and Ask answers in order and the answer says how it was found; a new task that resembles an open one is flagged instead of created. Local models has a "System 1 models" tab; mojoup-node status names them.
Every agent CLI is a runtime you can use. A catalogue CLI can be a team member, a specialist's runtime, the default runtime, the task-board orchestrator's or the conflict resolver's: the ones that speak the agent protocol run like any member; the others run as terminal agents — on the desktop and on a node — with a worktree, in Mission Control, the Timeline and the Office, and a card that says they are not governed per call unless the CLI's documented hooks are attached (Droid and Crush). The one runtime picker is everywhere a runtime is chosen. Every catalogue runtime reports usage — tokens where the CLI sends them, turns and time otherwise, plan windows where exposed — in the Usage pane, the dock and mojoup-node status. The Updates pane says when a catalogue CLI has a newer version, with the command to copy. An organisation's policy can allow listed CLIs or forbid terminal agents.
Home as HQ. One page: the header with the clock and Ask (a dialog over Home: memory answers first, then Open in Memory or Ask an agent), the explainer, a week strip with the day's routines, due plans and reviews as dots, Needs you / Routines / Team chips, a row of stats, Run now, a feed of large cards — needs you first, each with its status, who and where it runs, useful / not useful / pin / hide / refresh / Open, arrows and drag that work, at most twenty with "Show all" to the board — "Your other projects", and the dock's icon face (the chevron reveals the panel strip). On a team project the team's runs, waits and proposals are in it. Settings → "Show the feed" turns the feed off for the board. Home can open in its own window.
Quick open, jump, copy, reset. Ctrl+P opens files, conversations, tasks, plans and teams by name (> switches to commands); Ctrl+Shift+J cycles through what needs you with a "2 of 5 · next" chip; Copy context puts a conversation's, session's or task's context on the clipboard as Markdown; a terminal tab can be Reset or Restarted, and an agent's tab says what each does to the agent.
Teams: "Keep this one, remove the others" really removes the copies (it deleted on a read-only route and took the 404 as done), shows its steps, and the editor's Remove says what happened; the Teams page has a Refresh. Usage lives in the dock's Usage chip with a hover card; the right-hand pane is Git History; Settings → Attributions is Acknowledgements.
The one-agent first-start screen added in 0.89.10 is withdrawn: the first-start wizard opens as before.
Dependency fixes carried from 0.89.10 are bundled correctly in every build from this version (the 0.89.9 and 0.89.11 development builds were not).

0.89.13

Memory: Set up works from every Find scope. The header's On switch, Refresh and Set up, the Set up sheet and the banner strips were dropped unless Find was on "This repository"; they now show in every scope and mode, and the More menu's "Set up memory…" opens the sheet.

0.89.12

Memory stops reloading, and the picture scales. The host re-sent the whole memory graph on every change it heard (the graph file, the local runner's progress, a setting) and every picture rebuilt; sends are now coalesced and dropped when nothing changed, and a changed graph updates in place with the camera and selection kept. Rings, the universe and the maps are hierarchical: a tier over sixty items shows one hub per group with its count, press a group to open it (breadcrumb, Back, Escape); topics are capped at twelve plus "Other topics"; only the biggest names show at rest. Shelves draw the selected chip's connections. "View here" answers in words when a file cannot be read and gives up at fifteen seconds; a connector with several files lists them. Set up is reachable from the header in every mode, the More menu, the Find panel, the palette and the explainer, and its first step explains finding by meaning — what it is, what you get, what you lose without it, where it runs — with the local model, a hosted provider, or finding by words as the choices. The Find field has an "in Everything / Code / Knowledge / Project" choice and "Trace a connection…". The Globe picture is now Universe.
System 1 models. A model has a kind (generate, embed, rerank, classify, vision, speech, world) and one service serves the fast kinds behind the bundled runner, Ollama, LM Studio or the gateway under one rule: nothing above internal leaves the machine. A reranker (Qwen3-Reranker-0.6B, self-tested at install so a broken copy is refused) puts Find and Ask answers in order and the answer says how it was found; a new task that resembles an open one is flagged instead of created. Local models has a "System 1 models" tab; mojoup-node status names them.
Catalogue CLIs are runtimes you can use. A catalogue CLI can be a team member or a specialist's runtime: the ones that speak the agent protocol run like any member; the others run as terminal agents, with a worktree, in Mission Control, the Timeline and the Office, and their card says they are not governed per call. The runtime picker is in the member editor and Settings' default runtime; a forbidden or missing CLI says why. Every catalogue runtime reports usage — tokens where the CLI sends them, turns and time otherwise, plan windows where a CLI exposes them (Hermes), "not measured" with the reason elsewhere — in the Usage pane, the dock and mojoup-node status. An organisation's policy can allow listed CLIs or forbid terminal agents.
Home as HQ. A day strip (routines, plans, releases, pull requests as dots), Needs you / Routines / Team chips, a row of stats, a feed of large cards — needs you first, each with its status, who and where it runs, useful / not useful / pin / hide / refresh / Open — and the dock's icon face. On a team project the team's runs, waits and proposals are in it. Settings → "Show the feed" turns the feed off for the quieter board.
The one-agent first-start screen added in 0.89.10 is withdrawn: the first-start wizard opens as before.

0.89.11

Memory: the hierarchy in every picture, and the reference's card. Every layer has a hub and every group a hub with its name and count; memory has a folder level drawn as bubbles with counts that open on Expand. Force draws each group as a starburst on a spoke from the centre, Circle and Hex pack the same clusters, Rings keeps a sector per topic, the globe gains the hubs and bubbles. The card shows what a thing is, its badges, path and actions (View here, Open on device, Copy path, Expand, Fly to) and its Connections: point at one to light the link, press it to follow — select, fly, and the card rebuilds. View here opens a viewer over the canvas. Find is now "Find or ask": a question runs the lookup on Enter and "how does A connect to B" traces a path, with the answers lit on the picture and Ask an agent one press away; Set up (sources, upkeep, browse by topic) is a sheet; the page no longer scrolls under the picture. Shelves is the fifth Map layout, the nine tiers as you had them; a switch groups every picture as nine tiers or five themes. Names are budgeted: at rest only hubs, captions and the biggest items are named, the rest on hover, selection, a Find hit or zoom; ring captions no longer stack. The page switch says "This repository".
Copies of a specialist are really removed. "Keep this one, remove the others" on the Teams page deleted each copy on a route the organisation only reads, took the 404 as done and reported success while every copy stayed. It now deletes at the organisation (the route the editor's "Remove from your organisation" uses), says a copy that was already gone or one a team still uses by name, shows what it is doing step by step ("Giving Researcher to Acme API…", "Removing copy 2 of 3…") with a bar, and keeps the result on screen before closing. The editor's Remove shows "Removing…" and its result; the Teams page has a Refresh.
Usage moved to the dock. The plan-usage bar left the title bar: the dock's Usage chip shows the tightest window as a short name, a mini bar and the percentage ("low" / "full" in words past 80%), a hover card lists every provider's windows and credits, and a click opens the Usage pane.
The right-hand "Commit graph" pane is now "Git History".
Settings → Attributions is now Acknowledgements.

0.89.10

Security release

This release fixes a security problem. Update as soon as you can.

Dependency security fixes. DOMPurify moves to 3.4.17 (two sanitiser bypasses, one rated critical, in the library that cleans every piece of Markdown and HTML an agent sends to the screen), Zod to 4.6.7 (memory exhaustion on an oversized collection, CVE-2023-54404; it validates every frame a host accepts), and MSAL Node to 7.1.1 (the authorization-code flow could send its parameters to an attacker-chosen endpoint, CVE-2026-109461; it signs the desktop in to Microsoft Entra). The build tools' undici and fast-uri move to patched versions too; they never ship in the app.
First start for a brand-new person. With no project open the app asks one question, "What would you like to work on?": open a repository, the installed signed-in agent is preselected, and a prompt with three starters (tour the repository, run the tests, fix a bug). Start opens the project and sends the prompt; when the first turn ends the Inbox suggests setting up a team. The step-by-step wizard stays one link away, and Settings → Help gains "Your first ten minutes". In an organisation the screen offers its existing projects and teams.
Every agent CLI, one picker. A catalogue of 34 agent CLIs (Claude Code, Codex, Copilot, Cursor, Gemini, Hermes, Kiro, Amp, Aider, Goose and the rest) ships as data: the app detects which are installed and their versions, and the Updates pane lists them with a copy-the-install-command action for starred ones. Wherever a runtime is chosen the list is now one searchable picker grouped Favourites / Installed and signed in / Installed / Available / Not on this platform, installed-only by default, with a star to pin favourites. A CLI without the agent protocol runs as a "terminal agent": the terminal bar's new agent button opens it in the project folder, its runs reach the ledger, and it says plainly that it is not governed per call. mojoup-node runtimes find prints the same list.
Usage bar. The title bar shows each signed-in provider's tightest plan window (5 hours, day, week or month) as a small bar with the percentage, and says "low" or "full" in words past 80%. The Usage pane lists every window with its reset, credits, the account in use with a switcher that warns which sessions would restart, and a 7- or 30-day cost estimate marked as an estimate at standard rates, not the bill. Claude Code, Codex, Copilot and Antigravity are measured from what each CLI exposes; the rest say "not measured". mojoup-node status prints the same.

0.89.9

Memory is one control. Globe, Map, Timeline and the shelves (Applications, Skills, Routines, and the repository's Roadmap, Architecture, Plans, Governance and Library) are one canvas with one Find, one legend and one selection: our extra layers sit over the four ARMS layers in every picture, clicking an item flies the camera to it and draws its connections, and pictures cross-fade into each other with a Motion switch. The Mojo Up mark sits at the centre as the repository's instruction file: press it for what the repository is and where it is going, and its edits are ticked on the Timeline. Application icons sit in hex frames, skills sparkle, bubbles are sized by how often an agent reached for the item in the last thirty days. The Routines week calendar moved to the Routines view.

0.89.8

Memory as a globe. The Memory view's picture switch gains Globe beside Rings and Shelves: the four layers (tools, routines, memory, skills) as shells around the repository's instruction file, memory sliced by topic in the view's colours, hover for names, click for details, double-click to open the file. A 2D Map with Force, Circle, Hex and Rings layouts and a Timeline of every item by its last change sit beside it, and / finds anything and flies the camera to it. Adapted from RUBRIC Agentic OS v2 (Jay E at RoboNuggets, MIT) with credit.

0.89.7

Security release

This release fixes a security problem. Update as soon as you can.

Node.js security fix (CVE-2026-111497, high). A flaw in Node's Brotli decompression let a hostile server or request take over the process that decoded it. The node and the repository hosts now run Node 22.23.4, which fixes it along with nine other Node security issues; hosts already set up move to it on their next start. The desktop app runs on Electron's own Node, which no Electron release has patched yet, so until one does it never asks for or decodes Brotli, and its servers refuse Brotli-compressed requests before reading them. Electron moves to 44.9.3, which replaces a compromised certificate authority.

0.89.6

First start deploys specialists once, and says what happened. In an organisation the wizard lists the organisation's own specialists first, ticked, and creates only the missing ones; it saves one at a time ("Saving Scribe… 2 of 4"), and if a save is slow it reads the list back and says what exists rather than "may not have been saved". A retry never makes a second copy: the same specialist is used again, a different one with a taken name is saved as "Scribe 2" and says so, and every create carries a retry key the organisation honours (AIOE 0.63.1). Before, the wizard waited for the wrong name and too briefly, and each retry made new copies.
Keep one of identical copies. Teams → Specialists notices when you own several identical specialists ("3 copies of Generalist are the same — keep one"); the review keeps the original, moves every project onto it, and removes the others, only when you press it.
"No longer use in this project" is a person's choice only, and is recorded in the audit trail with who, as is "Use in this project".

0.89.5

An agent's status says what it is doing. Mission Control no longer sits on "Starting" while an agent works: the start-up briefing used to run as a hidden turn of its own, and an agent that acted on it (picking up its task from the board) worked unseen until a watchdog cut it off after three minutes. The briefing now goes out with the first prompt, so the work happens in a normal, counted turn, and the status reads Starting, Thinking, Calling tools (with the tool's name), Needs approval and Idle — the same words in Mission Control, the Agents view, the live monitor and the node. Each start also saves a model call.
The Office cards show where each agent runs, grouped as this workbench (with the WSL distribution, dev container or SSH host named), each node, other people's workbenches and the cloud. On a Teams or Enterprise project, teammates' agents appear too — working or idle, their task and place, refreshed every 20 seconds — from the project's shared record of runs; prompts and files are never shown.

0.89.4

Security release

This release fixes a security problem. Update as soon as you can.

OpenCode below 1.18.33 is not started on Windows or WSL. Those versions let a remote tool server's sign-in run code on the machine (Pillar Security's advisory; no CVE was issued, so scanners do not flag it). The Updates pane marks OpenCode as a security update with a link to the advisory, and a session refuses to start it until it is updated. Linux, macOS and OpenCode 2.x are not affected. AI Workbench's own sign-ins were never exposed: it opens them without a shell and only for web and Obsidian links.
The docs site updates itself after a release. A stable release now tells the docs site, which regenerates its release notes, settings reference and install scripts within minutes.

0.89.3

Memory proposals and history, rounded out. An agent is told once why an earlier note was rejected; a decision that went stale is re-read before it is proposed again; on a node, memory proposals can be accepted, rejected or opened from the dashboard and the /memory-proposals command; "As it was on" also works on the Ask page and the Rings; each line of a comparison opens the item at both points; and a retrospective reads memory as it was when the plan started.
A node's join never sits silent. mojoup-node join says what it is joining at once, and every probe it runs (runtimes, graphics card, each repository's memory) has a time limit; one that does not answer is listed as "not checked yet" and filled in later.

0.89.2

Agents propose, the team reviews. What an agent adds to a project's memory on Teams and Enterprise — notes, decisions, lessons — now lands as a proposal: the team's operations manager accepts or rejects it, or hands it to a person, who sees it in the Inbox with the change in words and Accept, Reject and Open. A person's own writes stay direct, the agent sees its own proposals while its run lasts, and the policy can set who reviews (nobody, the manager, a person). Memory → This project lists what is waiting. The organisation's index gains the same with AIOE 0.62.0.
A memory push can no longer lose items. The hub applies a push call by call and journals it, so a push that resumes later keeps every item; it writes the index once at the end, at a quarter of the bytes.

0.89.1

Memory keeps its history. Every push, write and removal is a revision the hub keeps: ask memory as it was on a date, from the "As it was on…" picker in the Memory view or with the tools' as-of point, and Compare two revisions in words. History costs what changed, not a copy per push; it is kept every revision for 30 days and then weekly for a year, which the organisation's policy can change. The organisation's index gains the same with AIOE 0.61.0.
A restricted level. Projects can be classified Restricted: only Sovereign-ready providers and local models may be used, the classifier always runs and blocks secrets, personal information and prompt injection, unlabelled memory is served as restricted, and an unlabelled item in a restricted or confidential project is never embedded by a hosted model.
The meaning model serves on its own. A repository asking to find memory by meaning starts the local embedding model without a chat model running; it stops after ten idle minutes and shows in Settings → Local models.

0.89.0

Memory finds by meaning as well as by words. A question to memory is matched on what it means, not only on the words it shares, using a small model that runs on this machine: AI Workbench offers to download it once from the Memory view (139 MB), or uses the one you already run in Ollama or LM Studio. Confidential and restricted items are never sent to a hosted model for this, and an organisation's policy can turn meaning off or keep it local. Answers say once whether they were found by meaning, by words, or both; a home that keeps no vectors answers by words as before. The organisation's index gains the same with AIOE 0.61.0.
Full access still applies the floor. No agent runtime is started in its own bypass mode any more: it stays where it asks, and the workbench answers at once, so the short list of commands the workbench never runs is now stopped under Full access too. You see no prompts; the Access picker says so. Codex runs one mode down in every mode so the floor sees its commands. Operations shows how many commands were checked.
The mouse on Windows, in the node interface. After the console is put in raw mode the node puts the mouse flag back and re-sends its request, so the wheel and clicks reach the dashboard in Windows Terminal; mojoup-node doctor has a Mouse line.

0.88.5

Every view and every Settings page explains itself. "How it works" tiles now cover all twenty-one views in the side menu and six bigger questions: spaces and editions (Free, Teams, Organisation), nodes with the mesh and your own VPN, local models, security, the architecture model and source control. Settings → Help has a Help entry in the side menu, a link to the AI Workbench docs site with "Read more" where a page matches, and each explainer can be searched for.
A closed explainer is never gone. Where its tile was, one quiet "How it works" line brings that one back, and every row in Settings → Help shows "Hidden" with its own "Show again".

0.88.4

Mark a session or a project. The chip beside the context meter opens a picker of your organisation's labels (or Public / Internal / Confidential / Restricted). A mark is a floor: what an agent reads can still raise the session, lowering what observation raised stays confirmed and audited, and the mark is what memory and exports inherit. A project's mark is the floor of every session in it and the default for its memory; in an organisation it is the project's classification. The organisation's policy makes marking optional or required: when required, an unmarked session cannot send its first prompt, and an unmarked project is flagged once and refuses dispatch.
"How it works" on every Settings page, and a search in Settings → Help that finds any explainer by a word in its text and opens the page; the Commands palette finds them too.
A Mojo Up AI Cloud account on the Free plan keeps its space read-only instead of showing errors: the card says the space is your account only, with "Make a team" and "Subscribe"; a Free team sees that writes wait until it is on Teams. Nothing is signed out, nothing is retried, reads go on, and the mesh is never offered on Cloud.
AIOE 0.59.0 schemas mirrored (the organisation's clear on the heartbeat answer).

0.88.3

Policy in words. The organisation's rules are named the way a person reads them ("Commands agents may never run", "Branches agents never change directly") in the Inbox, the notifications, the Settings cards and a refusal; the clause ids stay in the audit detail and a tooltip. The policy manifest now carries every label, so the organisation's console shows the same words.
How it works. Plans, Teams, Source control, Roadmaps, Decisions, Library and Architecture open with a short collapsible explainer with an animated picture, in the Watchlist's style, and Settings → Help gathers them.
Organisation teams. An administrator's "refresh teams" order re-reads the organisation's teams on this machine (desktop and node); a proposal names the owner it went to.
When an organisation's licence ends. A workbench or node whose Enterprise AIOE answers "licence required" keeps the organisation's space and its data, read-only, and shows the organisation's message on the organisation card, the space switcher, the node's status and doctor; nothing is signed out or deleted, and the mesh agent stops. A machine an administrator removed is signed out of that space and told why. An administrator's clear deletes that organisation's data on the machine (tokens and keys, teams, policy, catalogue, skills, design systems, cached projects, boards, plans, memory, inbox, conversations, organisation secrets, a node's held work, the mesh state; with the wider scope, the working copies of the organisation's projects' repositories, never a Free project's or another space's), tells the person in words, and acknowledges once.
Vite 8.3.5 in the renderer's build tooling (three advisories in its editor launcher).

0.88.2

A new team never overwrites one the organisation holds. "Add to your organisation as a new team" reads the project's teams and the library first and takes a free id when the id is held; every save names the version it read, and the organisation refuses a save that does not. (On 21 October, an "add" from a repository whose project already used the team wrote its local copy over the organisation's A-Team, Feature squad, Diagrammer and Researcher.)
Nothing the "Not under management yet" dialog removes is lost. Every definition you choose not to use is kept 30 days: the Teams page lists them with "Add to your organisation as a new team", "Download as JSON" and "Forget", and a differing row says which fields differ before you press Done.

0.88.1

Teams have an owner. Every organisation team and specialist shows "owned by <name>"; the owner (or an administrator) can hand it to someone else from the editor. With the organisation's teams.changesNeedOwner setting on, a change by anyone else is sent to the owner to accept: the card says so, and the owner sees "1 change waiting for you" with Accept and Decline. Members get a stable id, so a rename keeps a member's identity and history. Two more organisation settings: teams.manage (who may edit) and teams.templates (whether new teams may be made from templates).
The operations manager's git isolation switch is greyed out: the manager works in the main tree.
Updating on Linux no longer needs a terminal. Install hands the package to the system's package service, which asks for your password through the desktop; where that is not there, "Open a terminal" starts your own terminal outside the app. The app restarts once the new version is in.

0.88.0

A project in your organisation runs only the organisation's teams. On a project whose home is Mojo Up AI Cloud or an AIOE, every team and specialist is the organisation's record: the Teams page shows This project (what the project uses) and Your organisation's library (the rest, with "Use in this project"), and nothing else. "Keep on this computer", "Add here", "Not found in your organisation" and the wizard's scope choice are gone. A new team made here is made in the organisation, for this project. A team the organisation stops granting to the project finishes its turn, stops with a note and is audited. A session always starts on the organisation's current version. Local team files in a managed project are offered once as "Not under management yet": add to your organisation, use the organisation's team instead, or discard; a repository can keep a note of the teams it uses. Projects with no home keep their local teams. Each machine reports how many definitions are still unmanaged. (Phase 1a of the teams plan; the owner role and proposals follow with the organisation's half.)
The node's secrets warning clears at once after k or mojoup-node secrets migrate moves the key into the machine's key store; no restart needed.
Logs rotate. The desktop's, the node's, the service's and the updater's logs rotate at 20 MB keeping three older files, and an agent tool's stack trace is logged as one line.

0.87.4

A floor no mode can lift. A short list of commands an agent must never run (wiping the machine, stopping the node service or the workbench host, and your organisation's own list) is refused before any mode, grant, approval or bypass is consulted, at every place the workbench or a node sees an agent's command: the agent tools' permission requests, the built-in agent, the terminal hooks and the tool gate. The refusal is said in words, recorded on the run and audited.
Verified tool servers. A node checks an organisation's tool server for it: started in a throwaway sandbox with no secrets and only the package registries reachable, its tools listed and compared with what the catalogue declares, stopped within a minute. The Connectors page shows the verdict in one line. A machine that cannot sandbox refuses the check rather than run an unverified server in the open.
Model fallback per class. Your organisation can set an ordered chain of models for the fast, standard and strong classes. A provider that is rate-limited is benched until its reset; one that is overloaded hands the rest of the turn to the next in the chain; a runtime with prompt caching never switches mid-turn without asking you. Your own explicit model choice on a member is never overridden. The run records which model finished the turn and why.
Archived catalogue entries are no longer offered, with their own words wherever a withdrawn entry is refused; pinned entries sort first.
The workflows' actions are pinned to commits, and a pull request that changes a dependency manifest needs "deps" in its title or the dependencies label.
Schemas mirrored from AIOE v0.56.0.

0.87.3

Security release

This release fixes a security problem. Update as soon as you can.

Tool servers no longer inherit the host's environment. A tool server the workbench starts for an organisation's catalogue, or for a server that names a secret, now gets the same filtered environment an agent CLI gets: the workbench's own tokens and key files never reach it. Under a policy that denies the machine environment it gets only its own configured variables and the basics.
Secrets without a keyring. On Linux without a keyring the desktop no longer writes secrets as plain text: it encrypts them with a key in the Linux secret service, or in a protected key file with a warning, migrates an existing plain-text file on first start, and never overwrites a file this session cannot read. Settings → Secrets says where the key is kept, with "Move it into the keyring" when one is available.
A node sees new releases again. The node's update check sent its organisation token to Mojo Up's public feed, was refused, and fell back to a file the feed does not serve. It now asks the organisation's feed first, sends the token only there, and installs exactly the release its check chose, so a pinned or approved version holds at install time.
No burst of refusals at a node's start. The node renews its sign-in before it starts its hosts and its first calls, a renewal failure is said once with its real reason, and the desktop's shared board carries a fresh token when it reconnects.
Memory pushes no longer start over. A batch the organisation refuses as too large is halved and resent; batches are limited by size as well as by count; a push resumes from the last accepted batch.
The file watcher skips agent worktrees and build output, so a repository with many worktrees no longer hits the watcher's limit.
A host shuts down inside the desktop's grace period and names the step it is waiting for.
The Mesh page says "Relay busy, trying again shortly" instead of an error when the relay is busy.

0.87.2

Teams keep their projects. Removing a project from a team in the editor, and a team "not found in your organisation", are handled the way AIOE 0.54.2 expects: a project is only ever added through a save, removed through "no longer use", and a card that lost its project offers "Add it back to this project". The specialists shared by every project on a computer keep one link per computer, not one per repository.
One team per id, never merged. A team published under an id another team already holds goes up under an id with the project's name on it, said once; a team identical to one the organisation already has is used as it is, with no copy made.
Purview on a node checks for the person. A node's Purview check runs for the person attached to it, named to your organisation with the project; with nobody attached it says so and what to do. Every Purview refusal is a sentence with a remedy, never a bare code. mojoup-node doctor and status show Purview readiness. The policy stays as strict as before.
The node's secrets key. A key kept as a file beside the secrets says so in one short line with the remedy first, and k on the dashboard (or mojoup-node secrets migrate) moves it into the machine's own key store (Windows DPAPI, the macOS Keychain, the Linux secret service).
The node's monitor. c is explained: it keeps the CPU and memory readings on the dashboard's status line after you leave the monitor. mojoup-node input-test shows what the terminal sends the node, for checking the mouse and paste on a machine where they do not work.
The Teams page's own refresh request reaches the host again.

0.87.1

A node works on the projects it belongs to. With an organisation on AIOE 0.54 or later, a node reads the projects it holds: its member checks keep a project owner an owner, its history knows the members, and a project it isn't on, or one that was merged, is said once in words. Costs show in your organisation's currency again.
A node acts for the person it works for. Reads about a person (the coordinator, pull requests, decisions, trackers) say who they are for, and wait while nobody is attached instead of being refused. "Not a member" names the person, never an id.

0.87.0

Updates always arrive. A desktop or node no longer goes without updates when the organisation's update feed is busy or refusing: it retries within minutes, falls back to the public feed after half an hour, and still follows your organisation's update policy there (a pinned or approved version, a deferral, no unattended installs). Security and reliability fixes are never held back by a deferral.
The node opens on its dashboard. At a local terminal, mojoup-node opens the dashboard, with the conversation a screen of it: /dashboard and /repl (or Esc and c) switch between them. Over SSH and on simple terminals the conversation stays the home. Repositories show by name, never by id, and a node started in another terminal is found and attached to, not shown as "not running".
A sharper logo on the node. The header mark is drawn in fine braille dots: the circle and the cube, six rows tall.
The mouse and paste work in Windows Terminal. Clicks, the wheel, pasting and y to copy now reach the node on Windows (it runs on a newer Node 22). Where the mouse can't work the footer says so, a paste never runs a command, and q gives the prompt back at once.
Agent CLIs start in the workbench terminal on Linux and macOS. Copilot CLI, Claude Code and Codex installed through nvm or npm now find node when the app was opened from the desktop launcher, not only from a terminal.
A node stops asking for what only a person can do. It no longer registers projects, reads the inbox or the organisation's currency, and a refusal from the organisation is said once, in words, instead of retried.
Team cards keep their text inside the card.

0.86.1

No more being throttled by your own organisation. The Teams page could ask your organisation for projects and teams about 40 times a second when it was told to slow down, which tripped the rate limit and starved the mesh, the heartbeat and other calls. Every call now shares one budget per sign-in, well inside the limit; a "slow down" is obeyed for as long as your organisation asks; identical requests are shared; the page keeps the last good list while it waits and says so. An idle workbench now talks to your organisation about twice a minute, and Settings → Organisation shows what each part asks for.
Fewer needless calls. The labelling rules are no longer re-read (and the sign-in renewed) on every memory change; the mesh check and the subscriptions report no longer run on every status; the relay doesn't reconnect every minute while throttled; the Updates pane checks each item once every six hours ("Checked 2 hours ago", with Check now).
Team saves that fail stop politely. Saves of one team go one at a time, a team changed elsewhere is merged and saved once, and after a few failed tries the workbench keeps it on this computer and tells you once, with Try again.

0.86.0

The node's new look is the default. Framed panels in the Mojo Up colours, the cube in the header, and every screen — the settings screens, the local model, models, the live monitor, the log, status, doctor and help — drawn the same way, with the mouse working on all of them. The plain look is still there (Preferences → Dashboard look, or --renderer classic), and the Linux console and simple terminals use it by themselves.
Copilot is "Ready" only when it runs. A CLI counts as installed only when its version command works, so a gh whose Copilot command is gone no longer shows Ready or "up to date"; the card says "Not installed — signed in to GitHub as …" with an Install button, and its terminal stays off until it's installed. The node says the same.
The built-in agent is always on. It can't be switched off any more: the workbench's own features (memory, the Scribe, drafting, evaluations) run on it. Your organisation still decides which model providers it may use.

0.85.0

Set up a repository for agents. From a repository's row in Projects (or the end of the project wizard): a checklist you review before anything is written — a section in AGENTS.md (mirrored into CLAUDE.md and Copilot's instructions) with the build, test and lint commands it detected, your organisation's required rules in a section of their own, tool servers from your organisation's catalogue only, its hooks and the skills that fit, and the first memory build. Your own text is never touched; running it again shows what changed; a section your organisation no longer requires can be removed with a click. A node writes the organisation's required parts by itself.
Context sized to each member. Lean, Standard or Full, chosen from the member's model, plan and runtime and shown on its card ("Standard context · chosen for Claude Sonnet on your Claude Max plan") and in the session panel; change it per member or team, or let your organisation set and lock it.
The node's terminal. The cube in the dashboard header; the mouse in the new dashboard look (click a request, an action, a palette entry; the wheel scrolls; Shift- or Option-drag still selects text), with a click never acting on a request that moved under it; y copies what is selected, even over SSH; a paste always goes into a field as text and never answers a question.
Your GPU on Windows and WSL. The live monitor and the workbench's System tab now read Windows' GPU counters — how busy it is, dedicated and shared memory, the right adapter — including for GPUs that share system memory, and from WSL; the monitor's lines fit the terminal.

0.84.0

Design a specialist in a conversation. From the Teams page's New… menu or the wizard: a few plain questions (what it does, who uses it, sources, tone, outputs, rules, tools, volume), a draft with its face, model and an indicative monthly cost, then the wizard's own editor to adjust and save. Skills and tools come only from your governed catalogue; the model only from what your policy and the project's classification allow; your organisation can set a default model per class and lock it.
Foundry members run tasks. A member on Microsoft Foundry now runs tasks on its published agent, with every tool call answered on your machine through the session's own gates, DLP and approvals; every call to Foundry goes through the local proxy, which holds your sign-in and enforces the policy's project and model. The member card and the session panel say where it runs. Built against a test server: try it on a real project and tell us what you see.
Manage a node from your organisation's console and phone. Install or update agent CLIs, set the local model, start at login, updates, routines and settings as orders; watch the node live, answer its waiting approvals, stop a member or restart it. The node says "Managed from the console by …" while it happens, and audits every change. A policy clause can limit or switch it off.
The node's terminal. A live monitor (p or /monitor: CPU, memory, GPU, disk, the model's speed, with sparklines, and mojoup-node monitor for scripts); frames drawn as one unit and only changed lines written, so nothing half-draws over SSH; the Mojo Up colours; and an optional new dashboard look to try (mojoup-node --renderer ink, or Preferences → Dashboard look) — the standard look stays the default.
Tokens per second now shows for a local model started with a key; GPU temperature shows on the workbench and the node. Wording no longer names the mesh provider.

0.83.0

Everything the node's command line can set, from its terminal screen. The dashboard and the palette (/ or Ctrl-P) now have screens for the local model (pick the GPU by name, the backend the machine has, the model with "fits / tight / too big", and the load settings with their limits; start, stop, restart), models (downloaded, your organisation's approved list, download or remove), agent CLIs (install, update, sign in), the service (start at login), updates (check, install, channel), joining and setup (with a QR code; setup resumes at the first missing step), the hub, remote control, secrets, routines and display preferences. Each screen runs the same command the CLI does, asks once before changing anything, and shows what the organisation has locked and by whom. Over SSH the scrollback mode reaches every screen step by step.
Publish to Foundry from your organisation. An administrator can ask one of your nodes to publish a team's Foundry agent, as the organisation; the node keeps the organisation's credentials in memory only, publishes with the same steps a workbench uses, and answers in words with a reason when it can't.
Teams and your organisation. A project owner or contributor can take an organisation team into their project with "Add here". A team merged by an administrator is followed to the record that remains, and one that has gone missing is marked "Not found in your organisation" and never recreated.
Locked runner settings everywhere. The desktop refuses a local model setting your organisation locked, as a node does, and the Local models hub shows it as "locked · Managed by …".

0.82.0

The Teams page is one list. Every team and specialist appears once, in its own category (This repository, This project, Everywhere). When you're connected, the page says once that they are kept with your organisation; a card is marked only when it's the exception: only on this computer, changed here and not yet shared, changed in your organisation, or changed in both places. "From your organisation" lists only what isn't here yet, with where it's used and "Add here"; specialists stay specialists, with their faces.
One team editor. Editing an organisation team or specialist opens the workbench's own editor; what only the organisation decides (what it's for, which projects use it, node pools) is its "In your organisation" section. A specialist kept everywhere is now one organisation record across all your projects, never a copy.
Skills drafted from real work. When a task needed several review rounds, a suggested skill lands in your Inbox — names and hosts replaced, never quoting outside content, checked by data protection. Look at it, save it to the repository or for yourself, send it to your organisation, or dismiss it. Before a task goes to a person, a stronger model gets one attempt, when your project's classification and budget allow.
Specialists evaluated on nodes. Your organisation can ask a node to run a specialist against a set of cases; a judge scores each one and the result comes back in words.
Microsoft Foundry members (first rounds). Choose Microsoft Foundry as a member's backend, with the project and model your policy allows; sign in to the project; saving the team publishes the member's agent, and its card says where it stands. Removing a member asks before deleting its agent. Running tasks on Foundry comes next.
Removing an old Claude Code copy works. The Updates pane removes an old npm copy on the first click, inside your machine or WSL distro without opening a terminal, rechecks by itself, and lists every other copy with its path. The copy in use is never offered.

0.81.0

Security release

This release fixes a security problem. Update as soon as you can.

A session that has read outside content says so, and can be made to ask first. Web pages, outside tools, the built-in browser, tracker comments read back, replies from other agents and memory from the web mark the session. Its approvals say so, its audit rows carry the sources, and timers never approve for it. With the organisation's afterOutside: ask, anything beyond a read waits for a person one risk level higher. Outside text reaches agents fenced as data, never as instructions.
Control a live session from the web and your phone. Turn it on for a session from its menu or the side panel (off by default). Watch it, send prompts, interrupt, stop and answer approvals from Mojo Up AI Cloud or your organisation's console and phone app; the composer shows who is controlling it, and the tray's switch ends it everywhere. Only the session's person controls it; people it is shared with may watch.
Evidence before a skill is approved. Your organisation can ask a node or workbench to try a skill on a few tasks with and without it; a judge model grades both and the result sits beside Approve in words. The calls go through the model proxy, so data protection, budgets and the usage ledger apply. How often each catalogue skill is loaded is reported to the organisation.
A friendlier node terminal. Approvals in a bar with their risk, a status line, a command palette on / and Ctrl-P, a QR code beside the sign-in code, colours for light terminals and NO_COLOR, log follow and filter, and a scrollback mode used by default over SSH.
Provenance for copied code. provenance.json lists every file copied or ported from elsewhere, and lint checks that copies still match.
A node never reports a blank GPU name; the organisation's runner orders are read from the shared device orders schema.

0.80.0

Security release

This release fixes a security problem. Update as soon as you can.

A permission you give reaches only your own turns. "Allow for this session" is now held by the workbench for that session and that person; an Agent2Agent call, a routine or another person's node run never inherits it, never offers "always allow", and runs in the member's configured mode. Claude Code no longer saves always-allow rules into the repository's .claude/settings.local.json from the workbench's sessions (rules already there are left alone — check that file for lines you didn't add).
OpenCode and Kilo members follow your permission modes. Each member is started with permission rules written from its mode — a supervised member is asked before edits and commands — and the gate's and your organisation's blocked MCP servers are switched off for it. The adapter is ready for OpenCode 2.
One risk scale for every approval. Every approval says its risk from 1 to 5 in words; levels 4–5 (discarding work, deleting branches, reading secrets, deploys, force pushes, destroying resources) wait for a person in every mode and only a project owner can approve them. Every audit entry an agent writes carries its run id, so one id joins the workbench, your organisation's audit and Sentinel.
History is always synced, and you choose who sees each conversation. On an organisation project no more questions about uploading: every conversation goes up as it happens. Team Work runs are the project's; Chat and Research stay private until you choose "Everyone on the project" or chosen people ("Who can see it…"); conversations shared with you appear under "Shared with you".
A panel beside every session. Chat, Research and Team Work get a collapsible side panel: where the session runs, how full the agent's context is, progress, changes with their actions, and usage.
A node's local model, configurable everywhere. mojoup-node runner lists GPUs, sets the backend, GPU, model and load settings and starts or stops the model; the workbench's Nodes page has a Local model section; your organisation can configure it too.
Your organisation sees what a repository gives its agents (instructions, hooks, skills, MCP servers by name), and a project's classification sets the minimum rating a model provider needs. "Create with Claude" is now "Create in Chat".

0.79.1

History after a project merge. History sync keeps its place when a project is merged into another: what it already sent stays sent, the surviving project is read once in full, and a conversation the survivor already held its own copy of is never overwritten — it stays on this computer, says so in the History pane ("kept here"), and can be uploaded as a new conversation.
Each machine says which teams it holds. A workbench or node signed in to your organisation reports the teams and specialists it holds and where each lives (shared from the organisation, a project's, or kept on this computer), so the console can show which machines hold which team.
A node that joins while it runs picks the join up. mojoup-node setup and join tell the running node, which registers, connects and joins the mesh without a restart; a node also notices a join from any process within a minute. Messages name the node ("Joined Mojo Up as mju-jp-node"), never its id, and the dashboard says when the join is being picked up and what the mesh is doing.
Waking from sleep never signs you out. A sign-in that ran out while the computer slept is renewed and the call retried; network trouble keeps you signed in; only Mojo Up refusing the renewal signs you out. Mojo Up AI Cloud and organisation workbenches alike, on Windows, macOS and Linux, and nodes too.
A + beside Chat, Research and Team Work in the side menu starts a new session in one press.
Waking from sleep never signs you out. A sign-in that ran out while the computer slept is renewed and the call retried; network trouble keeps you signed in; only Mojo Up refusing the renewal signs you out — on Windows, macOS and Linux, for workbenches and nodes alike.
A + beside Chat, Research and Team Work in the side menu starts a new session in one press.
Smaller fixes. Every terminal tab always shows its close button. Updating graphify or an agent runtime in the Updates pane says it is updating, says how it ended, and checks the version again by itself. Claude Code's row offers to remove an old npm copy left beside the native install. The project card no longer lists which machines hold a repository.

0.79.0

Agent history keeps everything. Each agent session's activity is appended to its file and never cut short, so a long Team Work run's whole log reads back in Agent history, the Runs timeline and the activity graph. Only age lets history go: Settings › Team Work › "Keep agent history for" (30 days by default). A 30,000-event session opens in well under a second, and a disk that refuses writes is said once, with new activity held until it can be saved.
Nodes and Teams hubs catch up. A node follows a project merge as soon as its heartbeat says so and shows it in mojoup-node status; a node renews the tasks it holds as soon as its machine wakes. A Teams hub names every machine holding each repository, and a hub project's owner sets when a stale task goes back to the queue.
Signing in, finished. The Teams wizard signs a member's runtime in inside the dialog, as the project wizard does; the sign-in folder works on WSL, containers and SSH machines; an older Claude Code falls back to typing /login; a CLI that signs in without leaving a file is recognised once its login ends.

0.78.0

Device orders as your organisation issues them (AIOE 0.37.1). An order is never applied past its expiry and one that arrives expired is refused once, in words; a body over 4 KB is refused; a machine's facts — its models, runtimes and DLP state — go up on the heartbeat when they change, not only at registration; at most 200 answers go per heartbeat, oldest first; an order issued to every node of a project reads "Your organisation asked every node of Mojo PSA to install Codex — done here", naming who asked. The node CLI's help lists the console's refusal codes in plain words.

0.77.0

Manage a machine from its CLI and from your organisation. mojoup-node models list | download | remove, runtimes list | install | remove, dlp status | configure and config get | set --json work with the node stopped. A desktop or node applies your organisation's orders — download or remove a local model, install or remove an agent runtime, configure DLP, set a lockable setting — once each, audited, answered in words on the heartbeat, and shows "Your organisation asked this machine to download Qwen 2.5 Coder 14B — done" in the Inbox. A new setting, Approved models only, lets the organisation lock machines to its approved models. A model download started in one process is joined by any other that asks for it.
With your organisation (AIOE 0.35–0.36). A merged project's notice names who merged it and whom to ask; an idle desktop learns of a merge at its next heartbeat; each repository in the Projects view lists every machine holding it, by name, with its state. Risk owners read back by name; a person's claim is refused in the person's words; "Work alongside" and "Queue after" go through the project's home; parts land on the plan's branch with their wait's title. The teams client follows the organisation's build: catalogue role and skills kept, a clashing id retried, a specialist still in use named, the organisation's runtimes and models offered after your own.

0.76.0

Signing in to a CLI from the wizard, in sight. Sign in runs each CLI's own login (claude auth login, copilot login, codex login) in an empty folder the workbench owns — never in your repository, so no project trust prompt or project tools get in the way — with the terminal shown inside the wizard step, "Signed in as …" said in words, and plain sentences when the CLI is missing or the terminal could not open. Dim text in the terminal's light theme is readable again.
Explore from Agent history. The Agent history panel's header opens the activity graph for what the panel shows — a run, an agent, a task or a conversation — carrying its type chips, search and the time window being viewed as the graph's starting filters, so list and graph show the same thing.
Teams on the platform, as the organisation takes them. The member schema the workbench publishes follows the organisation's build: its catalogue role and skills kept, refusals and fields it cannot hold yet named per field, a field-by-field merge that tells you what the organisation kept, and a project's owners and contributors publishing through the project's own route.

0.75.0

Uploading history says what it is doing. Upload and Share in the History pane show "Uploading… 2 of 3", then "3 chats and research uploaded" or "Could not upload: <why> — Try again"; "Keep here" is confirmed; and a conversation you answered for is never offered again, under any project — including after a project merge. The pane also says what is waiting to go up and when your organisation cannot be reached.
A project merged into another is followed. When your organisation merges a project away, the workbench and nodes re-point the project, every repository and its boards to the surviving project from the registration's answer, re-register, and tell you once. A merge into a project you are not a member of says so and names who can add you; local work carries on.
Teams and specialists on the platform. Every team and specialist of a project on Mojo Up AI Cloud or an organisation is published to it on save and at sign-in, pulled back and merged field by field (telling you who changed what), with "Managed with your organisation" / "Kept on this computer" on the card and a member's Microsoft Agent 365 identity shown when registered. Fields the organisation cannot hold yet stay on this computer and the card says so. The member editor no longer drops the thinking level on save.
Many repositories, matched with the organisation (AIOE 0.34.1). Removing a repository shows what was cancelled, released and abandoned and when it is kept until; a removed repository's boards are read-only for 30 days and come back on re-registration; a second clone of the same remote is adopted; parts are placed on the machine that holds the repository, with the machine's own refusal shown; held tasks say what they wait for, by repository and task.

0.74.0

A machine that goes away no longer keeps its work. A task claim is a lease: renewed while the machine works, visible as "Anna-laptop is on it · renewed 2 min ago" or "not heard from for 25 min", and never a bare id. A stale claim can be taken over from the task card, Team Work, Mission Control or the Inbox — audited, naming the person and both machines — and the new machine resumes from the work branch the old one pushed (mojoup/wip/<task>). A machine that comes back cannot overwrite the take-over: its late writes and releases are refused. Recovery leaves tasks other machines hold alone. Against an organisation this needs AIOE 0.33.0; a Teams hub does it all now.
The person on the board. Every change a person makes carries their name. A person's task waits for them instead of counting as stalled, their comments reach the agent working the task, "assigned to you" lands in the Inbox on every edition, and a person's task shows Start / Mark done / Blocked instead of Execute. Dispatch never hands a person's task to an agent.
Changes made elsewhere. A board changed on another machine, the console, the phone or a tracker wakes the run, the review loop and dependent tasks here as a local change would. Shared-board saves are field by field, and when two people changed the same thing both are told. A plan closes out from the board's state, so it finishes after a restart too.
Many teams in one repository, told apart. The calling agent is known by its session and team, never by name alone; budgets and roadmap rows are per team; risks, decisions, questions and the Inbox say which team, only when more than one is active.
A person's picture. A human team member shows their organisation picture, else their GitHub picture, else a pixel character; any member's picture or character can be chosen per team.
The mesh as a map, with full screen and each machine's logs; History links on every timeline and an explorable activity graph of an agent's run (tools, commands, files, questions), full screen and exportable as PNG or SVG; Agent history browses the whole log, a page at a time.
One project, many repositories. A plan's parts in other repositories are created only once the plan is approved, wait on each other across repositories, and are cancelled everywhere when the plan is abandoned. A cancelled part blocks what waited on it instead of reading as done; the plan never wraps up on a timer past an open part. "Merge the plan" and "Open PRs" act in dependency order with the PRs linked; a library part can carry a release step. A part for a repository on another machine is placed through the project's home; a second clone of the same remote is recognised; removing a repository asks first with its open counts and cleans up; the per-subscription agent cap counts across every repository on this computer; every surface names the repository, never a root id.
Boards kept on this computer are reported to the organisation, so two writers never fight over one GitHub repository or Azure project; the mirror settings warn when the organisation already mirrors the same target. Quiet hours follow the organisation's notification preferences while signed in. The Architecture map keeps a folder's sub-folders in its layer.

0.73.0

Security release

This release fixes a security problem. Update as soon as you can.

Roles are checked on every call, and approval is a real gate. A worker can finish, block or comment on its own task and file unassigned tasks; it can no longer move a task to done, approve, submit a plan, rewrite the brief or hand tasks to others — those stay with the operations manager, reviewers and the planner, and on a team without an operations manager only a person. Every refusal is one sentence and is audited; a person's terminal CLI and hand-overs follow the same rules. A task on a draft or abandoned plan is refused by every dispatch path, and abandoning a plan cancels its open tasks and releases their claims.
Lessons are proposals until you keep them. An agent's retrospective lesson is filed as proposed, with a needs-you record in the Inbox, and reaches future agents only once you keep it.
Your plan decisions are audited — approve, abandon, acceptance verdicts and approvals by text marker — each naming who made them. A planner's per-task estimate is capped at the policy's per-task budget; a plan can no longer lift it.
GitHub Issues and Azure Boards go both ways. Changes a person makes on the Issue or work item — state, assignee, labels, comments — are read back onto the board, writes are field-wise so neither side overwrites the other, one writer owns each item, and who did what is attributed on both sides.

0.72.1

The mesh says when your plan stops it, and when your traffic is slowed. With the mesh agent 1.5.1, a plan that does not include the mesh (or has lapsed, or has no room for this machine) is read from the agent itself and said in your organisation's own words, and the agent is never restarted in a loop. When your organisation's relay slows this computer's mesh traffic, the mesh card and mojoup-node status say so once, with the allowance, and afterwards when it last happened.

0.72.0

Design reviews against your design system. A design system with rules carries a review checklist (DESIGN-REVIEW.md). After a task changes interface files, its review checks the change against your default design system: a finding that breaks the system holds the task like any review feedback, lesser ones are listed. Reviews against your organisation's design system reach it (the task, the findings and who reviewed, never code), and each design system's page shows its latest reviews. A team can turn Design review off.
The mesh on Mojo Up AI Cloud, and your plan said plainly. Where your organisation offers the mesh (Cloud included), this computer joins it. When the plan does not include the mesh, has lapsed, or has no room for another machine, the mesh stops once with a sentence saying so, never signs you out and does not retry in a loop. Your organisation's relay limits show on the mesh card.

0.71.0

Pictures made on this computer. The workbench can download stable-diffusion.cpp and an image model (Stable Diffusion 1.5, SSD-1B or Z-Image Turbo, each with its licence and whether it fits this machine) so the Diagrammer and agents make pictures with no key, on any plan, and nothing leaves the machine. Settings › Local models › Images; nothing downloads until you click, and a graphics card makes it practical.
Account tokens only where they belong. A repository gets your GitHub or Azure DevOps token only when it has a remote on that provider, and your organisation can limit which owners qualify. A refusal says who decided, and the token never reaches a log.
Design systems your organisation offers wait for you. An offered design system reaches your agents once you choose "Add for me" or "Add to this repository"; your organisation's default is always there.

0.70.0

See where Team Work's tokens go. Hover a member to see its context against the model's window (it drops to "Fresh context" when a task starts) and the tokens on its current task. Each task shows its tokens in and out, cache reads, cost or "included in your subscription", and who spent them. Each plan shows a running total with your Claude five-hour and weekly windows, and "Where it goes" breaks it down by member and by implementing, reviewing and planning.
Team Work is cheap by default. Where a team has not chosen, workers run on Sonnet at medium thinking and the operations manager, planners and reviewers on Opus at high thinking. No more than three agents of one subscription work at once (Settings → Team Work); the rest wait, said on their card, and reviews are never held. New teams review only the tasks that need it (careful, large, security-sensitive or with failing tests) and the rest once at the plan's end; existing teams keep reviewing every task. A fresh task now costs one model turn instead of two, and workers get a shorter briefing. A team still running the top model everywhere is offered "Apply cheaper defaults", never applied by itself.

0.69.0

Design systems, on their own page. Settings → Design systems shows every design system your agents can use (yours, this repository's, your team's and your organisation's) with its colours, fonts and logos, its rules and voice, what changed in this version and how often agents loaded it. On any plan you can make one locally with a guided form, or import a folder or .zip, keep it for yourself or commit it to the repository, edit it and save it as a .zip. One default reaches your agents: your organisation's, else your team's, else the repository's, else yours. A team hub's owner sets the team's default; "Share with your organisation" submits yours for approval (AIOE 0.28 or later). An agent loading a design system now says so in its activity. Where your organisation turns off people's own customisations, creating and importing are turned off too.
Signing in proves itself to your organisation. After you sign in, this computer tells your organisation when, and keeps that fresh, so attaching to a node or taking control of a screen is not refused for want of a recent sign-in. When the organisation asks for one, the workbench renews it quietly, or asks you to sign in again; it never signs you out. Settings → Organisation shows when you last signed in on this computer.

0.68.1

Team Work spends far less of your model's limits. Each task now starts its agent with a fresh context instead of on top of the earlier tasks' file reads, diffs and tool output: a worker starts every new task fresh, and the operations manager and reviewers start every review fresh. A conversation is kept only for a revision or re-review of the same task, and never reset while its own task is still in progress. A revision that reaches a worker who has moved on carries the task, its acceptance, the worker's own summary, the feedback and where the work is, so nothing depends on memory. Each reset shows in Team Work's activity.

0.68.0

A teammate's GitHub and Azure DevOps accounts come from their organisation profile. On an organisation project, a human team member is the person; the team no longer asks for a GitHub username beside them. Under the person it shows what they linked ("GitHub @ada · Azure DevOps Ada Park, from their organisation profile"), or that they have not linked yet, with "Link your accounts" for yourself. Tasks assigned to them are assigned to the right account at GitHub, Azure Boards or Jira (AIOE 0.27 or later). Without an organisation, the field follows your board: a GitHub user, searched across GitHub as you type, or an Azure DevOps user, searched in your Azure DevOps organisation, to whom work items are assigned.
Every project on this computer in your organisation's console. Remote control now sees all your projects and each of their repositories, with whether its host and its WSL distro or SSH host are running, not only the repository open now.
Design systems as a .zip. A team hub's owner can share a design system from a .zip, and save one as a .zip, in the same layout as your organisation's console.

0.67.1

Security release

This release fixes a security problem. Update as soon as you can.

(0.67.0 was built but not published: a test of its own failed on Windows. 0.67.1 is the same release.)

On a node several people use, each person's agents use only that person's keys. A provider key is taken from the set of the person the agent works for; a person with no key gets none, said in words, never someone else's.
Secrets sealed to their owner. A personal secret is now sealed to the person it belongs to as well as to their devices, and a node opens it only into that person's work. A home that once listed your devices is never sent a personal value unsealed; withdrawing a node seals your "Follow me" secrets again without it. (Organisations from AIOE 0.24 take the new seals; older ones keep the previous kind.)
Keys stay where they are allowed. The inference proxy no longer follows a provider's redirect to another address while carrying a key; it refuses with a sentence.
Terminal checks tightened. An answer for a held tool call counts once, for that exact call, for two minutes; under your policy's "require controls", a terminal that cannot be checked is refused with the reason; the workbench's own board tools are recognised by where they come from, and a repository's server may not use their names.
Cloud agents in your CI hold no write token while they work. A separate step pushes their branch, only to mojoup/cloud/…; on Azure Pipelines the brief cannot be expanded by the pipeline. An organisation's Cursor key starts work only as your verified email.
Only your organisation's own catalogue counts as your organisation's. Skills, agents, instructions, prompts, tool servers and design systems a repository commits under .mojoup/templates/ are shown as the repository's and get no organisation privileges, and that folder is kept out of git.
Your own files. A personal customisation reached through a link opens only when the link leads to another of your own customisation files.
Architecture review. Only the person at this computer can start a review by several models, and stop only their own.
Signing in is not slowed by the security report. Registering with your organisation no longer waits for this computer's security report (seconds on Windows); the report follows as soon as it is measured.

0.66.1

Security release

This release fixes a security problem. Update as soon as you can.

A repository can no longer install hooks on your machine. A cloned repository that committed files where your organisation's catalogue keeps its hooks, plugins and marketplaces could have had those hooks written into your own Claude Code, Codex and Copilot settings when opened, and its marketplaces treated as your organisation's. Only what the workbench itself received from your organisation is installed now. Update if you open repositories you do not trust.
Terminal checks hold for large actions. A tool call or prompt over 1 MB from a CLI in the workbench's terminal is now checked (a tool call asks you, a prompt is stopped) instead of passing unchecked; a check cut short in Codex stops the action when your policy says to.
Your sealing key is never replaced by mistake. When the key store could not be read, a new key could overwrite the old one and leave secrets sealed to this computer unreadable; it now waits.
Design systems and the catalogue. Stylesheets that tried to load from outside the design system in other spellings are refused, a design-system asset's size limit holds however it is sent, links inside a folder shared to a team hub are not followed, and catalogue entries named "." or ".." are refused.
Fixes. Codex config.toml hook edits keep the file's permissions and links; Copilot hand-overs clean up after themselves; the architecture review no longer freezes on unusual CODEOWNERS patterns, files its findings even when there are many, and stops counting unrelated findings as agreeing; a budget reading for another project never holds this one's work, and a stalled budget read no longer hangs the next ones. The workbench host also uses about a third less memory at start.
Your organisation's limits in words. On Mojo Up AI Cloud, a plan limit or request limit is said in its own sentence, with when to try again.

0.66.0

Agent CLIs in the terminal, all three checked. Codex and GitHub Copilot CLI opened from the terminal now go through the same checks as Claude Code: each prompt through data protection, each tool call held to your policy, and each finished tool call in the history as it happens. A CLI you open for yourself can read the task board (never change it), and its session is kept as one of your own conversations. Hooks written in Codex's config.toml show on the Hooks page and can be edited there, leaving the rest of the file as it was.
Nodes and your secrets. A node shows what it holds for each person, by name, and the person sees it in Settings → Secrets. When a node will not run your work because you have not allowed it, you are told where you started the work, with "Allow it to run your work". Switching "Follow me" on after a secret was kept seals it again for your nodes.
Design systems from a team hub. A team hub's owner can share a design system from a folder; the team's workbenches install it as a skill, with its fonts and pictures checked.
Your organisation's mesh. What a peer needs before it can be reached is now said from the mesh map, and when your organisation sends every mesh connection through its relay over HTTPS, the card says so.
Copilot credits are reported as credits, a count beside the spend, never as money.

0.65.0

Review the architecture. One action on the Architecture view, for a repository or the whole project: instant checks first (layers that depend on each other, areas outside every layer, areas everything depends on, documentation nobody owns, connections without a label, pictures out of date), then a review by several models whose findings are ranked by how many agree. Tick the ones to act on and they go to the Scribe, the Diagrammer, the Watchlist or the roadmap, held for review.
Cloud agents. Setting up a repository for a cloud agent proposes its files as a pull request you review first. Copilot tasks go through GitHub's agent tasks API when it is there; a Cursor key your organisation holds starts work as you, never as a shared account; each cloud run is a usage row; and a member can run in your CI (GitHub Actions or Azure Pipelines) on keys your organisation owns.
Signing in again, never out. When your organisation asks for a fresh sign-in before a sensitive action, the workbench asks and carries on; it never signs you out for it.
This computer's security, for your organisation. The operating system, updates, disk encryption, firewall and screen lock are reported where they can be read without asking for admin rights, and Settings → Organisation says what your organisation may require. The organisation's mesh says in words what a peer needs before it can be reached.
Design systems from your organisation. Your organisation's design systems arrive as skills, with their fonts and pictures checked, and agents are told to use the default one.
Secrets. Your own secrets at your organisation are sealed to your devices; nodes and people are shown by name; your organisation's own reminders replace the workbench's.
Fixes. The workbench's own tools page no longer runs who-gets-each-tool over the tool's name.

0.64.0

Agent CLIs in the terminal, with the workbench's controls. Claude Code, Codex and Copilot CLI opened from the terminal menu now start through your repository, with its connectors and, for Claude Code, the workbench's checks: each tool call is held to your policy (it may ask you in the terminal or refuse, never allow on its own), and each prompt goes through data protection before it is sent. Your own settings files are never written. Whether a check that cannot be made stops the action is your policy's choice (terminals.failClosed), shown on Settings → Data protection. Copilot CLI sessions can now be handed over to the terminal and back.
Secrets, end to end. A key bound to certain hosts is never sent anywhere else — through the gateway or by a tool that talks to its provider directly — and every refusal says who decided. A team hub on a machine that cannot protect its keys refuses new shared secrets when the team's policy asks for a key store. On a node, each person's secrets are released and used for their own work only, and a node acts only for the people who allowed it or whom an owner assigned. Your own secrets kept at a hub are sealed to your devices, so the hub holds only what it cannot read; a key stored on this computer can be kept as a personal secret instead. The local model's key is no longer on its command line, transcripts really move out of the repository, and the people who keep a secret are reminded when it grows old.
Microsoft 365 Copilot. A run it started carries on honestly across a restart of the workbench (a reply already written is delivered; otherwise it says what was lost), files it made go back as files, and its conversations are marked in history.

0.63.0

Customisations, all on one pattern. Agents, Skills, Prompts, Instructions, Hooks and Plugins each open as a list, a page for each item and one Add menu, with the same words for where an item lives: Just you, This repository, Your organisation, Your team, Built in. Tools now open from Connectors ("The workbench's own tools") instead of a page of their own.
Plugins, as Claude Desktop has them. Yours and Discover, every marketplace with search and categories, a plugin's page saying what it adds (skills, agents, commands, connectors, hooks), turn it on or off, update or remove it, and add a marketplace, upload, create a plugin or create one with Claude. Every command is shown before it runs.
Hooks in plain words. One editor for Claude Code, Copilot and Codex: when it runs, which tools, what it runs, a timeout, who gets it and which apps run it — and before saving, the files it will write. Codex's trust step is said where it matters.
Your organisation manages customisations (AIOE 0.19 or later, and Mojo Up AI Cloud). It can publish agents, instructions, hooks, plugins and marketplaces — offered for you to add, or put in place on every machine — limit which marketplaces and plugins may be used, whether people add their own, and whether hooks run. Share a skill, agent, prompt, instruction, hook or plugin with your organisation from its page: published at once for administrators, or waiting for approval (a decline says why). The console sees what each machine has (a hook's command is never sent).
Budgets. A budget change reaches your machines at once; an organisation that stops work when its budget cannot be checked is honoured while the platform is out of reach (local models carry on); a budget refusal is said in words, and a team is no longer started here when the organisation refused it for budget. Home shows the forecast, a lift in force, and the business area a project's budget comes from.
Costs at your organisation's prices. With AIOE 0.20 or later, calls are priced with your organisation's own price list, so the workbench's figures and the console's agree; Operations says so. Claude's five-hour and weekly windows and Copilot's premium requests reach your organisation.
Several people, several machines, one project. Plan numbers no longer collide between two clones of an organisation project. A node keeps an organisation project's plans, questions, history, settings and saved teams at the project's home, each written for the person the work is for; its private hub can be handed over (mojoup-node hand-over). A task that deals with a risk claims it.
Jira. Your organisation's Jira trackers show on the board beside GitHub Issues and Azure Boards.

0.62.1

Every repository reaches your organisation, even when its host is stopped. Repositories on a WSL distro that is stopped, a stopped dev container or an SSH host out of reach now show in your organisation's console, marked "host stopped", "distro stopped" or "unavailable", instead of going missing. The workbench reads each one's state without starting anything, every few minutes.

0.62.0

Costs in your organisation's currency. Every cost and budget shows in the currency your organisation sets (A$, €, £…), or in US$, never a bare "$". Your Mojo Up AI Cloud picture shows on your account.
Costs you can trust. Each model is priced as itself (a newer model is never charged at an older one's price; an unknown one says it has no price), cache reads and writes are priced, and the list of prices is dated. What a Copilot, Claude Code or Codex subscription includes is shown as included — worth its list price, never counted against a money budget. Usage reaches your organisation without gaps, and the policy's daily budgets warn (at the policy's own threshold) and stop the next model request when reached.
The mesh. A node whose key an administrator retired says why and how to join again, instead of retrying; signing out clears it.
Memory map. Turning memory-map sharing off offers to stop tracking a graph.json already committed (your copy stays).

0.61.0

Your project's work is the same on every machine and for every member. With your organisation's platform (AIOE 0.12 or later) or Mojo Up AI Cloud: - Plans and decisions are the project's: approve a plan or answer a question from any of your machines, the console or your phone, and the plan starts once, on the machine whose team runs it. A run can be stopped from the console or the phone, and its conversation says who stopped it. - Team Work is the project's: every member sees the run, who started it and the whole transcript. Chat and Research are yours: they follow you to every machine and stay private until you choose Share with the project (the answer, or the whole conversation). Existing history goes up only after you say yes. - Project settings and teams saved for the project are kept with your organisation: owners change them, everyone else sees them. A repository removed from the project elsewhere is offered for removal here. - GitHub Issues and Azure Boards sync through your organisation for its shared boards; the Tasks view shows the sync and, for owners, Sync now.
One Inbox everywhere. The workbench, the console and the phone sort records the same way; a snooze reaches your phone; Done on a record for everyone is yours alone; nothing is missed between checks.
Memory keeps its labels. Confidential memory an agent reads is treated like any labelled content (it is not sent to a public model), local-only results stay on this computer, and a team hub only shows each member what their role may read.
Updates on Linux that could not open the password window offer Install again, or Run in the terminal inside the app, then restart.
The Office opens on the team map (agent cards); the pixel office is one switch away.
A node with placement tags joins your organisation's mesh again.

0.60.2

Opening your organisation's project brings every repository. On a second machine, a project with three repositories arrived with one. Now every repository it has is listed, cloned into one folder or matched to one already there, each with the branch your organisation records.
Your workbenches keep up with the project. A rename by an owner reaches every machine; a repository added on another machine is offered here ("not on this computer: clone it, it is already here, or not on this computer"), and a changed remote is offered as an update. A changed .mojoup/project.json can be committed in one click.
Find people across your organisation. Choosing a person for a team searches your organisation by name or email; only people on the project can be chosen, and an owner can add someone first. People show by name, never by an id.
Landing an approved plan pushes on your organisation's projects (turn git.pushAfterLanding off to keep it local), and the GitHub Issues / Azure Boards mirror only imports on an organisation's shared board, which your organisation syncs.
The Dev Containers CLI installs on Linux when the app was started from the menu, or says npm is missing. This machine's own news (finished turns, notices, routines) no longer reaches your organisation's inbox and your phone.

0.60.1

The node's setup asks only what changes anything. "What is this node for?" listed things a node works out for itself (it always runs teams; it serves inference and DLP while its local model runs) and computer use, which a node does not serve yet. Setup now says what is automatic and offers sandboxing only where the machine can do it (Linux with Docker and NVIDIA OpenShell), saying why otherwise.
Leave an organisation from the node. mojoup-node setup → Leave <organisation> signs the node out (stop it first).
Data protection in mojoup-node status and the dashboard. Each repository says who checks what leaves the node — a local model and whether it is working, Microsoft Purview with its fallback, or the built-in patterns alone — and whose policy it is.
No more "Ed25519 Web Crypto API … experimental" line in the middle of the node's setup.

0.60.0

Security release

This release fixes a security problem. Update as soon as you can.

Every project you start in your organisation's space is the organisation's. With Mojo Up AI Cloud or your organisation's platform (AIOE 0.9.0 or later), a new project is registered with the organisation, which manages its sharing, memory and policy; you are its first owner. For something of your own, switch to the Personal space. Once others are on a project, its name is the organisation's and only an owner renames it. "Promote" is now File under a business area (Enterprise only), and removing a project you own alone works from here; one someone else is on is an administrator's to remove.
Nothing is left behind when a project becomes the organisation's. A project whose roadmap, architecture, project tasks, risks, runs, memory and pictures were kept on this computer has them copied up once. Its secrets move only if you say yes.
Several people on one project. Approving a plan claims it and the roadmap items it serves. If someone else is already on one, you choose: work alongside them, take it over (owners), or wait. Approving from your phone never takes anything over. Home shows who is working on what now, and held plans, roadmap items and tasks say who has them.
Fixes. The usage card shows a model's weekly allowance at its real percentage (1% read as full). A connector that takes a token no longer keeps an old sign-in error once it is connected.
Security. DOMPurify 3.4.16 in the window (Monaco's own copy included), KaTeX 0.18.2 under Mermaid, image-size 2, and patched dev tooling (brace-expansion, source-map-js, fast-uri).

0.59.0

Microsoft 365 Copilot can ask your specialists and teams. With your organisation's console (Enterprise, AIOE 0.8.1 or later), an administrator or a project's owner marks a team, or one of its members, "Callable from Microsoft 365". People can then ask it from Copilot, Copilot Studio or Teams. The work runs on their own workbench or a node they trust, with their own permissions, the organisation's policy, data protection, approvals and audit, exactly as if it had started here. The conversation shows "Asked from Microsoft 365 Copilot" in Chat and Team Work, questions come back to Copilot, and the answer, branch or files go back when it is done. The organisation's policy decides who may call and whether the work waits for the person's yes first.
Foundry IQ knowledge bases and Fabric data agents your organisation publishes connect as you, with your Microsoft account. Settings › Connectors says who still has a step to do: you (Connect), your organisation, or a Microsoft administrator (the permission or role to grant). Sensitivity labels on a knowledge base's answer are respected like a labelled file's.
Connectors that take a token (such as a component library's) no longer send you into a sign-in that cannot work. When the token is not set where the workbench runs, the connector says "Needs a value" and asks for it once on its page; it is kept sealed on this computer. A refused token is said in plain words.
Ask the Diagrammer is a button at the top of Architecture, beside the Picture menu, at both the repository and the project level.
Turned off by your organisation? Cloud agents and AI images now say where an administrator turns them on: the console's Policies › Cloud Agents, and Policies › Pictures › AI image models.
A project's cover is kept at the project's home and shows on every project's card, on Home and in the Projects view; an agent's cover goes to the same place.
Architecture reads more truly. An S3 client library alone is "S3-compatible storage"; Amazon S3 needs AWS evidence. Well-known public APIs are named (Frankfurter as the ECB's exchange rates), and a project's outside systems say which repository uses them.

0.58.0

The Diagrammer. A new specialist that draws your architecture and roadmap as pictures — Clean, Whiteboard, Animated, Isometric, C4 and 3D — from what the workbench already knows, so many pictures need no AI at all. Pictures are saved in docs/diagrams/ (or, for a whole project, at the project's home) with a "Picture" menu everywhere: save, download as SVG, PNG, draw.io, Excalidraw, Mermaid, Structurizr, CSV, PowerPoint (editable shapes) and the walkthrough as video or GIF. Add the Diagrammer in first start or Settings › Setup; ask it from Architecture, Roadmap, or "A picture" in Chat, Research and Team Work.
Architecture shows what your solution declares. Infrastructure, Data and Integrations views appear when the repository has them — read from Terraform, Bicep, CloudFormation, Kubernetes, compose, Prisma, SQL migrations, ORMs, package manifests, OpenAPI and MCP configs — each item saying where it was found. A Diagrams section keeps your saved pictures, says what changed since each was drawn, and refreshes them with a list of changes you approve.
Edit and import pictures. A picture editor (boxes, lines, groups, steps, tables, timelines and sequences; the layout stays automatic), and "Import a picture…" from a photo, a draw.io, Excalidraw, Visio or Mermaid file, or infrastructure files.
The roadmap on dates. An optional Target (a month or a quarter) on roadmap rows, and "What happened · What's ahead": real work so far, your targets, and a forecast from your recent pace where there is no target. The roadmap reader no longer drops rows with a | in a cell.
AI images, governed. Covers, styled pictures and illustrations from an API provider, your ChatGPT plan through Codex, or a model on your own computer — under your organisation's new AI images policy, with a daily limit, cost shown first, and every image marked AI-generated. Image models never draw a diagram's boxes, arrows or labels.
The clouds' own icons, downloaded on request under Microsoft's, AWS's and Google's terms.
Draw from your other tools. Claude Desktop, VS Code and Cursor can use the Diagrammer's tools through a paired, draw-only connection (Settings › Security).
Sign in with Claude for your WSL and SSH projects in one click; a token copied from a wrapped terminal line is accepted.
Git. The commit graph has a legend ("What these mean") that lists only the marks on screen. A commit's details show who made it with any co-authors, its exact time beside "1h ago", a button to copy the commit id and "Open on GitHub" (or your remote's name) once it is pushed.
Ask memory includes Microsoft 365. With Microsoft 365 connected, a Look up in Memory › Ask the organisation also asks your mail, files and meetings, as you, and shows that part with its sources beside the organisation's own answer; a switch leaves it out.
Commits on every timeline. A plan's, a task's, a roadmap item's and an agent's timeline can show the commits that belong to it, as the Timeline view does.
Chat. Pin a specialist in the Agent menu and new chats start with it. The starters are now a tour of the project, running the tests and tracking down a bug. Once a conversation starts, a quiet line under the composer says AI-generated content may be incorrect.
Teams without an operations manager. When you give one of its members a task, you choose whether the result merges on its own or waits for your review; work nobody chose for waits for you instead of sitting in Review with nobody behind it.
A human team member is a person in your organisation with Mojo Up AI Cloud or your organisation's AIOE; the free edition keeps the GitHub user.
Ask the Scribe opens one dialog everywhere it is offered, and with several scribes you pick which one writes it. An architect is no longer taken for a scribe.
Built-in browser. A camera button copies the page you see and saves it to Downloads.

0.57.1

Microsoft 365 grounding reaches your agents. When your organisation publishes Microsoft 365 (Work IQ) and names the app AI Workbench signs in with, Settings › Connectors shows "Microsoft 365 grounding" with a Connect button: sign in once with your Microsoft account and every agent can ask Microsoft 365, with your sign-in kept at the workbench and never shown to an agent. The block says plainly when it is on, and when it is not, whose step is missing.
Timeline. With commits shown, every run stays visible (commits sit in a band beneath the bars), short runs have a visible width and their real times on hover, "Now" stays on top, and the legend lists only what is on screen. "Showing the newest commits, back to …" offers to show only that span, and a custom range no longer leaves "7 days" highlighted.

0.57.0

Team members can work in the cloud. A member's "Runs on" can now be In the cloud: GitHub Copilot first, then Cursor, with Claude and Codex through your own CLI as a preview. The task goes out from the plan's branch (Copilot gets the task's GitHub issue, assigned to it), comes back as a branch the team reviews at the exact commit, and merges into the plan like any other work; changes you ask for go back to the agent as a comment. Cloud agents are offered only on a workbench signed in to Mojo Up AI Cloud or your organisation, and only where its policy allows that provider; the brief is checked for sensitive content before it leaves, every step is in the audit log, and the workbench's tools reach the cloud agent through your organisation, checked the same way as a local member's. Cloud work waits for your review by default.
Install and remove on Linux in one command. curl -fsSL https://ai.mojoup.com.au/install/workbench.sh | sh installs the desktop app — the .deb through apt on Debian and Ubuntu, the AppImage with its menu entry elsewhere, and it copes with Ubuntu 24.04's sandbox rules and a missing libfuse2 — and curl -fsSL https://ai.mojoup.com.au/install/node.sh | sh installs the node as a service that starts on boot (… | sudo sh -s -- --system for the whole machine). Add -s -- --uninstall to remove either one: it asks before removing your data, keeps it by default, and never touches your repositories. A Linux copy that cannot update itself now offers the command to copy.
Fixed: removing the .deb closes the running app first; a node installed as root runs as a system service; updating the node restarts its service on the new version.

0.56.0

Several plans at once on one team. A plan's work now lands on its own branch (feat/<plan>) and never straight on main; merging into main is the one step you take. A second plan asks "Run alongside" or "Queue after": alongside, a crew — a copy of the team for that plan, same members and instructions — works on it at the same time, up to "Plans that can run at once" (2 by default, 1 for a team on local models; Settings › Team Work and the team editor). Each running plan has its own colour on the board, the timeline, the office (a project table per plan), the team map and Mission Control, its own Stop, and its own usage on the card. When one plan merges into main, the others catch up at their next task.
Connectors, as Claude Desktop has them. Settings › Connectors adds a remote MCP server by name and address, signs in to it in your browser (the workbench keeps the token; agents never see it), and sets each tool to Always allow, Needs approval or Blocked. An agent that needs a connector you have not signed in to puts one item in your Inbox.
Source Control. Commits on the Timeline across the project, each saying where it is: being worked on, approved and going in, in the plan's branch, or in main. A Tags tab and Create tag from a commit — tags that publish a release are protected. The commit details pane can be resized and always answers. "Not committed" and "All committed" instead of "dirty".
The built-in browser, like VS Code's. Add to chat: an element (picked on the page), comments on elements, the console, a screenshot or an area — attached to the conversation you are in and checked like anything you paste. A ⋮ menu with developer tools, zoom, find in page, history, favourites, site permissions and clear storage, and Settings › Built-in browser. Device emulation with your own width, height and pixel ratio, phone, tablet and laptop presets, and user agents — agents can use the same presets. Favourites, history, permissions and sign-ins are kept per project, so you will sign in to sites again once in each project.
Terminals. Split a terminal right or down, and keep a terminal running after you close it (on Linux, macOS, WSL, SSH and dev containers it survives quitting the app, through tmux when it is there). "Open in terminal" in Mission Control hands a Claude Code or Codex team member's session to you in a terminal in its own worktree: the team knows it is with you, messages to it wait, and closing the terminal gives it back — briefed on what changed — without ever stopping the agent. Every take-over and give-back is in the audit log.
Sign in once, use it on WSL, containers and SSH. Settings › Models › Your subscriptions: "Use on all my machines" keeps your Claude Code token (from claude setup-token) or your GitHub sign-in for Copilot on this desktop and hands it to your own runs — and the model picker — on WSL, dev containers and SSH hosts, never written there and never to a node. Codex and Antigravity, which have no token to hand on, get "Sign in on <machine>".
Architecture. The description panel beside the map can be made wider or narrower, on the repository and the whole-project map, and the map refits as the window changes.
Chat and Research caught up with Team Work. A thinking level in Research for every researcher, coming back to Chat or Research reopens the conversation still running, one Stop that stops this run only, and research's longer phases said in plain words.
Secrets. Your own secrets ("Yours") can follow you to your nodes; an organisation can lock a secret or limit where it may be sent, and changes and revocations arrive at once. Data protection says plainly whether Microsoft Sentinel is connected.
Plain words. Approved work now merges — "Merge now", "3 approved commits waiting to merge", "Merged into main" — instead of "land" and "integrate". "Shaping the brief" and Plan › Do › Wrap up replace SEED and PAUL. Text that is cut off shows the rest when you hover or focus it.
Updates. Ubuntu updates ask for your password in a window again; old installers are cleared on every platform and on nodes; "Open download page" goes to Mojo Up AI Cloud.
Lighter hosts. Claude Code, Codex, Copilot and Gemini reach the governed tools and the task board over HTTP inside the host instead of one helper process per agent; the host's memory drops from about 101 to 76 MB and it starts faster (Node's compile cache). Old host versions are removed from WSL distros, dev containers and SSH hosts after an update (gigabytes on a busy distro). Long conversations cost the gateway about a third less CPU, and searching files for a rare word is about twice as fast.

0.55.0

Team Work keeps moving. A worker is given one task at a time on every path, and the team waits for a task's dependencies before starting it. Status checks no longer pile up behind an agent that is busy (they cost a full turn each, and could use up a 5-hour usage window), a task is no longer flagged for "repeated failures" because of questions it asked, and work on other tasks carries on while one waits for you.
When a task keeps failing, you see why. The question shows each attempt — how it ended and the agent's last words — offers "Other" for your own answer, and "Clear flag & restart" now clears the flag. "PAUL" is gone from the screen; it is "the plan".
Thinking level for Team Work. Pick Default, Low, Medium, High or Maximum beside the team in the Team Work composer; it applies to planning, reviews and every task from each member's next task. Runtimes without a thinking setting keep their own default, and say so once.
A plan's retrospective is filed when the plan closes, with acceptance re-checked or marked "checked before the work finished", follow-up tasks included, and an honest status. The Plans view marks those out-of-date verdicts too.
Work lands where your policy says. A repository that requires pull requests, or protects main, never has work merged into main automatically; agents cannot approve a task you asked to review; and you are told when a team's work would go straight onto an unprotected main.
Approvals. A tool call your approval settings allow no longer flashes "needs approval", sends a desktop notification or leaves a card behind; every surface counts the same approvals.
Mission Control. The close button always works, nothing overlaps the output, waiting messages fold to one line, a second resize corner and the size is remembered, one chip per agent, and it stays on the agent you are reading. Answer in the Inbox and Open on a toast go to the agent that asked. After you send, "Thinking…" shows until the first reply.
Inbox, Tasks and Plans. The Inbox shows its count in the sidebar, closes items that are done (an answered question, an update already installed, an agent running again), and the Updates pane no longer flickers. Tasks and Plans scroll, the plan graph's full-screen button works, and Team Work reopens the run still going.
Specialists have one name. Renaming keeps the same specialist, a save never creates a duplicate without asking, and deleting one always says what happened.
Git view. Remote tracking in the commit graph with one plain line and one action ("3 changes not on GitHub yet · Push"), Get the latest, Publish and Sync, all audited and within your branch policy; a clearer graph that no longer cuts lines off, and a marker on each commit for who made it — a teammate, an agent outside the workbench, or a person.
Settings. Data protection, first start and Setup offer the same choice — off, a local model, Microsoft Purview or both — and Purview never asks for a local model. Data protection says where telemetry goes (your organisation, Agent 365, Microsoft Sentinel through it, your own collector). "Apps on this computer" is now "Tools on this computer", hidden while off: MojoFlow never used it.
Secrets. This computer's own keys and the host's log lines are masked, a hub keeps "this machine" secrets to this machine, and a node can no longer change the team's secrets.
The inference gateway applies sensitivity labels the same way as the workbench.

0.54.0

DLP by edition. Free and Teams keep checking content with a local model. On Enterprise, an organisation whose platform has Microsoft Purview connected can have Purview check content instead, with no local model on the machine; only the organisation's served policy can choose that, never a repository's own file. When Purview cannot answer, the request is blocked or checked by the built-in patterns alone, as the organisation chose, and Settings → Data protection says who checks content and what happens then.
The inference gateway checks content the same way. The external gateway runs the same patterns, Purview and local classifier as the workbench, with the same rules for when Purview stands in for the local model; it holds no organisation token of its own. A Purview answer that was not evaluated is treated as Purview being unavailable, never as allowed.
Fixed: the usage banner no longer stops an agent on one model because another model's weekly limit is used up (an Opus agent showed "Fable is used up").
Fixed: turning off the local model no longer warns that a merge-conflict resolver on Claude Code's own sign-in will lose its model; a built-in agent orchestrating the task board is now counted where it was missed.

0.53.0

One setup, everywhere. First start and Settings → Setup walk the same steps with the same words and screens: This computer, Agent CLIs, Local model, What helps your agents. First start adds your account, your specialists and Done; Settings → Setup ends with the vault and companion apps, which first start does not need.
Runtimes look like the rest of the app. One row for every runtime, in the setup wizards and Settings → Models: its name, one readiness word, one sentence, at most one action, and the switch. Paths, versions and install commands sit under Details. A runtime with a newer version offers Update.
"Built-in agent". The runtime that comes with AI Workbench is called that everywhere, says what it is, and no longer shows a file path.
Chat & Team Work is now one choice: the task board orchestrator. It is the runtime a team's operations manager and the team chat use when the team names none, and it appears in both setup wizards under What helps your agents. The Chat, Worker and Worker-count settings are gone: chat and specialists follow your default runtime and teams follow their own definitions. An organisation policy that still sets them is ignored.
The host bundle is verified before every start. Every file the agents run, the built-in agent included, is checked against the app's own manifest before a host starts on this computer, in WSL, a dev container, over SSH or on a node, and each helper process before it is spawned. A changed copy is replaced once; if it is still wrong the host does not start and the change is recorded and reported.
A policy manifest with every release. Each release publishes a manifest of the workbench's and node's settings and security policies — types, defaults, who may set each, what can be locked, and the schema of the policy an endpoint accepts — and every machine reports which manifest it carries on its heartbeat. The organisation's platform and Mojo Up AI Cloud can read it from the release or from the machine itself, so a new workbench setting no longer needs a new platform release to be managed. Clauses that need platform features are marked as such, and a machine reports the policy keys it does not know.
The Updates pane shows work in progress. A row's button spins and says Installing…, Downloading… or Checking… for as long as the work runs, and prerequisite installs report their progress and failures.
Fixed: a parent label SharePoint applies in place of a requested sub-label is kept when it is no less sensitive; the labelling helper is found on Windows.

0.52.0

Labelled content is reported, blocked or removed before a public model provider. For each sensitivity the organisation's policy chooses what happens when labelled content heads for a hosted provider: report it, block the request, or remove the labelled passages and send the rest. By default Confidential content is removed and Restricted content is blocked. Marked content is found in labelled files, in text carrying a label's header, footer or watermark wording, and in text an agent read from a labelled file; content that was summarised is found by the local model, and when there is none the request is blocked instead. A CLI on its own sign-in cannot have content removed, so it is stopped and told why.
Purview labels from the organisation's tenant. Rules can name a label ("once a session has read Highly Confidential, no web fetches"), a label the workbench has not seen is looked up with the organisation, and the organisation can turn on Microsoft Purview's own data-loss check for prompts before they leave. Activity is recorded so the organisation can report it to Purview.
Labels that encrypt are applied to documents the agents write, through the organisation's SharePoint or an optional labelling helper an organisation installs itself.
The session shows its label. A chip beside the context meter names the label once a session has seen labelled content, lists what raised it, and offers Lower to the person at this desktop. A session a label has held appears in the Inbox. Data protection lists the organisation's labels and where each may go.
The mesh agent runs from one place, so Windows Firewall asks once per machine instead of after every update, and rollback orders from the organisation now apply to it.
Fixed: a request to a model with Anthropic's wire format could carry text the data-loss check had removed.

0.51.0

Microsoft Purview sensitivity labels. When the organisation's policy carries the labels clause, the workbench and the node read a document's Purview label from its own metadata (Word, Excel and PowerPoint, protected and legacy Office files, Outlook messages, PDFs on a best effort) and keep each session's highest label. A label decides where the session's content may go: Confidential to a model on this machine or the organisation's gateway, never a hosted provider; Restricted to this machine only. Attachments, file reads, an agent's own tool calls, the proxy and sandboxed sessions all enforce it, and the composer shows an attachment's label. Memory and documents the session writes inherit its label, and memory from a Restricted session never syncs to the organisation.
Repository policy is now Data protection. Its own page under Governance opens with who decides, then three questions: what leaves this computer, what agents may do, where it is recorded. Git and pull-request rules moved to Source Control.
Microsoft 365 for Enterprise. "Sign in with Microsoft" on the desktop when the organisation offers Entra, with the code as the fallback. The organisation can disable, quarantine or re-enable a specialist from its agent registry, and the desktop, hosts and nodes honour it within a heartbeat. Every run, tool call and model call becomes a run record the organisation can send to Agent 365 and Defender, with content redacted by default; every audit row carries a severity, and Sentinel detections ship with the docs. An account the organisation marks at risk sees why its approvals now wait for the desktop. Each team member may carry its Entra agent identity and sponsor.
The hub's address may carry a forwarded port, and mojoup-node join --hub --advertise tells the hub how to reach a node behind NAT or under a DNS name.

0.50.0

The team hub is the Hub, on any network. "Team hub" is now "Hub" in every sentence: a hub on your own network, with no cloud service behind it. Becoming the hub asks which network it serves — Tailscale when this computer has it, an interface on your LAN or VPN, or an address others reach you at (a DNS name or forwarded port) — and invitations carry that address. Nodes on a plain network serve their mesh endpoint over TLS with a pinned fingerprint (mojoup-node join --hub … --bind <interface>), so a hub works on a LAN or a VPN without Tailscale. Phones remain the one device that needs the Tailscale name.
Remote control is Connections, Reach this workbench and Paired devices. Settings → Security opens on what is connected right now — the platform you are signed in to with its relay state and heartbeat, the hub, paired devices with a live session, apps on this computer, attached nodes — with the kill switch and its one-sentence consequence. The ways in are three rows: Apps on this computer (was Local IPC), Devices on your network (the address, Pair a device with a QR code, the bind / port / network / fingerprint / TLS details collapsed) and Through Mojo Up AI Cloud or your organisation (follows your sign-in). Paired devices with Revoke as the one action.
The team wizard starts from the Teams page's template gallery. The same cards, tones and example avatars, "A blank team" as a card in the same grid; opened from a landing pick, the chosen card alone with one Change button and the name prefilled.

0.49.0

Local models and your own models on every runtime, without the Copilot CLI. A runtime is the agent process; a model source — the bundled local model, Ollama, LM Studio, Unsloth, a hosted provider — is a separate choice any runtime takes: Claude Code, Codex, Cline, OpenCode, Grok Build, Antigravity, Kilo Code, the bundled bridge, and the Copilot CLI in its own BYOK mode. "Ollama", "LM Studio", "Unsloth" and "Hosted / gateway" are no longer runtimes that need a Copilot install; a team saved with one of them runs on the bundled bridge, and is written back that way on its next save. The proxy between an agent and its model now speaks four wire APIs — chat completions, the Anthropic Messages API, the OpenAI Responses API (Codex) and the Gemini API (Antigravity) — against any model server, so the small-model repairs, guardrails, data protection, budgets and usage accounting apply whichever runtime carries the model.
Settings → Models says it in plain words. Model servers (no longer behind the Copilot switch), how agents reach a model (the proxy), the bundled bridge's limits (tool calls per turn, malformed calls in a row, the longest tool result), and a default model source for every runtime.
Local-model behaviour follows the model, not the runtime. The lean toolset, context probing, auto-compact and the small-model budgets apply to a Claude Code or Kilo member on the bundled runner as they did to an Ollama one.
The Teams editor and the new-project wizard. One runtime picker and one model-source section for every member, the runtime's own sign-in heading the list where it has one; the project wizard's Team step offers the same template gallery as the Teams page.
The first start holds until the computer can work. This computer needs a commit identity before Next; every agent CLI starts switched off and one besides the bundled bridge must be on, each row saying in words whether it is ready, needs its adapter, needs a sign-in or is not installed, with one button that installs or signs in and a spinner while it does; the default runtime is picked from the ready ones only. The local model defaults to "No"; the WSL networking fix is offered only when a local model is served. The "Who does the work" step is gone: the default runtime covers chat, plans and the work, and Settings → Models keeps the per-role overrides.
The first start asks about your account. A step after This computer: on your own, Mojo Up AI Cloud, your organisation's platform, or a team on your own network, each with the same sign-in Settings has. A sign-in that lands in another space restarts the app there and the wizard resumes on that step.
Install failures in plain words. "The adapter installation failed. Please try again." with the installer's last line beneath it, instead of an exit code. A program an installer put in ~/.local/bin (uv, Claude Code) is found at once, not only in new terminals. Choosing a model for memory or a role answers straight away when the runtime needs a sign-in first, shows a spinner while it lists, and ignores a second press.
Mojo Up AI Cloud and your organisation are two sign-ins. Settings → Organisation shows a Mojo Up AI Cloud card ("Sign in to Mojo Up AI Cloud": free on your own or with your team) and a Your organisation's platform card (work email or platform address) as separate things. A space holds one sign-in, so the other card offers "Add a space" instead of a second sign-in. Nothing says "Sign in with Mojo Up" any more.
Spaces can be managed. "Manage spaces…" in the space switcher and a Spaces list on Settings → Organisation: rename, sign out (the open space), remove (its data is kept aside on this computer). No more duplicate "waiting for you to sign in" rows: adding a team reopens the one that is waiting, a sign-in starts once rather than on every launch, a sign-in approved into an organisation another space already holds goes to that space, and signing out turns a team or organisation space back into a waiting one.
Open a project that already exists on the platform. Signed in to Mojo Up AI Cloud, your organisation or your team, "You have no projects yet" offers "Open a project from …": pick one of the platform's projects, then say whether its repository is already on this computer (the folder's origin is compared with the project's and a mismatch is a warning, not a refusal) or should be cloned here, on the branch the project records. "Start a project here" and "Open a folder you have" no longer read as the same thing. A project with several repositories gets its primary now; the others are added from the Projects view.

0.48.1

Your organisation's ring chooses the channel. On an Enterprise platform a ring can be put on nightly builds or stable releases, and every workbench and node in it follows: a nightly the ring offers is taken even when the machine's own setting says stable, and a stable offered to a machine on a nightly takes it back. Settings → Updates says when the ring has decided. So "put the canary ring on nightlies" is one action on the platform's Updates page.
Settings → Updates shows the real values for the check interval, the channel and the two switches; the old pane controls had shown defaults.
Windows builds carry the mesh agent again. Every Windows build since 0.47.1 shipped without one (the staging step read its own folder as D:\D:\… and gave up), so a Windows workbench or node signed in to an organisation reported "This build carries no mesh agent" until it fetched one. And the fetched one was refused on a node started from a PowerShell 7 window ("installer signature is missing"): the signature check now runs Windows PowerShell by its own path without pwsh's module path, as the node's updater already did.

0.48.0

Updates, the MojoFlow way. Settings → Updates says "You have the latest version, 0.48.0. Checked 2 h ago", shows this version with its state and a Check now, and carries the three switches MojoFlow has: Check once a day, Download updates in the background (fetch a new version as soon as it is found, so updating is one click; nothing installs until you say so) and Tell me when one is ready (one notification per version, and a dot on the tray and taskbar icon until you install it), then the channel and the update source. An organisation can lock all of them. The Updates pane keeps the list of everything that updates and links to the settings instead of carrying its own.
Your organisation can update or roll back a machine now. An Enterprise administrator orders it from the console; the next heartbeat carries the order, the app fetches the version the organisation chose — an older one too, which it never takes on its own — tells you who asked and why, and installs a minute later (or when you press Install now). A node runs its safe self-update (mojoup-node update --allow-downgrade for a rollback); the mesh agent is fetched whatever its own setting says. The console's buttons are the AIOE's next release.
The mesh row says why. "Mojo Up AI Cloud offers no mesh", "not signed in to an organisation" or "the Mesh switch is off" instead of "nothing to fetch".
Linux installs itself again. A .deb install was sent to the download page for every update, because the package carried no marker saying it was one. The package carries it now, and the app also asks dpkg who owns its executable, so this version is the last one installed by hand: from here a .deb updates in place, asking for your password, and restarts.
The bundled mesh agent is a real binary again. 0.47.1 and 0.47.2 shipped the feed's archives where the agent should have been, so the copy that comes with the app never ran; only the agent fetched from your platform did. The build now unpacks what it stages.
Withdrawing a release. A workflow marks a published nightly or release as withdrawn on the portal, so no machine is offered it, and Mojo Up AI Cloud is told at once; every release now reaches Cloud within a minute of publishing rather than at its next pull.

0.47.2

Characters draw again. On a fresh install the first-start wizard, and the Welcome window with no project open, showed every agent as a blank space and offered "6 characters to choose from": the sprites were handed to the office only once a project's window had mounted. They are now applied the moment they load, before anything draws, and a preview drawn too early is redrawn when they land. Windows and Linux alike.
The Teams page starts somewhere. With no team yet it opens the way every view does: a hero with three ways in — a specialist, a team through the wizard, an empty team by hand — and under it the team templates as cards, each drawn as the characters it would make, with its roster in words. Your organisation's templates come first, on a shelf of their own.

0.47.1

The mesh agent is back, and keeps itself current. 0.47.0 shipped without the organisation's mesh agent. It now comes from your platform's own release feed: the workbench and the node fetch aioe-mesh from Mojo Up AI Cloud, or from your Enterprise organisation's platform, which offers each ring the version it approved, on the app's update cadence and when you sign in. Only a machine signed in to an organisation that offers a mesh, with the Mesh switch on, fetches one. The download is checked against the release manifest (and on Windows the Mojo Up signature), the agent is restarted on the new version, and the previous one is put back if the new one does not start. Settings → Updates shows an "Organisation mesh" row; mesh.autoUpdate (off, notify, install) is the setting, and your organisation can lock it. The fleet sees which agent each machine runs.
Updates pane. A newer memory engine is offered like any other update, with the version on the button and the detail saying the upgrade is optional; an action the host carries out keeps its button pending until the host answers, so a click is seen to do something and cannot start the work twice.
Installing a node is one line per OS; the install scripts default to Mojo Up AI Cloud's feed and are served from the docs site and from every AIOE's own address.

0.47.0

Updates come from Mojo Up AI Cloud. The app reads its releases from https://ai.mojoup.com.au/releases/v1/workbench/<channel>/latest.json, or from your organisation's own platform when you are signed in to an Enterprise one (it answers for the ring your computer is in, and may hold a release back or offer an earlier one). Settings → Updates → source still overrides it with a URL or a folder. A release the publisher withdrew is never offered, and a manifest for another product is ignored.
Nightlies and stable releases are signed with Mojo Up's publicly trusted certificate (Azure Trusted Signing), the installer and the app inside it, and now the node executable too. The certificate on the dev box signs test builds only.
Your licence decides the edition. Signed in to Mojo Up AI Cloud or an Enterprise organisation, the workbench asks the platform for its licence (the plan — Free, Teams or Enterprise — and what it allows), checks the platform's signature on it, and keeps it with the sign-in; the edition follows it, including through two weeks of grace when the platform cannot be reached. A Cloud team held to the Free plan is Free. Without a licence (an older platform) the organisation's own plan stands in.
Nodes, the mesh and organisation backups are offered only where the licence allows them.
Your organisation's settings policy reaches the updater. A locked update channel, source, signature rule or node auto-update from the organisation wins over the local setting, as it already did for hosts and nodes.
The node updates from the same feed. mojoup-node update reads the platform's release manifest (its channels are stable and nightly; preview still works as a name for nightly), sends the node's token so an Enterprise answers for its ring, and the install scripts read the same manifest. The node package is built and signed from CI and published with every release.
The organisation sees which mesh agent each machine runs, from the version bundled with the app or the node package.
CI fixes. A repository under a symlinked folder (macOS's /var, a Windows short name) has one worktree container whichever way it is reached; a write outside the agent's worktree is reported by the path the tool named; a routine named by a number is never confused with an id starting with that digit.

0.46.4

The setup guide sees an install the moment it finishes. After Install on Git Credential Manager, the Git rows now read git again, so the row turns green without restarting the app; Re-check and the live refresh do the same. Re-check and the live refresh were reading everything but git.
Installing shows it is working. The row and its button say "Installing…" with a spinner and tell you to approve the password prompt, until the install ends and the row has been re-read. Starting Docker and the other Install rows do the same.
Installing Docker Engine on Linux no longer stalls. Docker's own install script asked for a second sudo password that had nowhere to be answered, so Install sat waiting. It now fetches the script and runs it, and adds you to the docker group, in one step behind a single system password dialog. When it finishes the setup guide, and the install's own terminal output, tell you to sign out and back in once so your account can use Docker, then Re-check.
Docker that is up but refuses you now says so. Right after Docker Engine is installed on Linux your login session is not in the docker group yet, so every call gets "permission denied". The row used to offer Start Docker, which cannot help; it now says to sign out and back in once, then Re-check.
A quiet log before you open a project. The app logged "dropped … no ready host for its root" every minute on the Welcome screen, where there is no project and so no host to ask. It now logs that only for a window that has a project but no ready host.
A CLI that is not installed no longer floods the log. Reading documents for the memory graph through an agent CLI (Copilot, Codex, Claude Code, Antigravity) started a fresh agent for every chunk, so a CLI that was missing or signed out failed hundreds of times, two warnings each. After three failures in a row it now stops starting the CLI for two minutes, says so once, and tries again after that.
The dock shows AI Workbench's icon, not a generic cog, on Ubuntu. The window now carries the same name as its launcher, which GNOME needs to tie the two together.
A first-start wizard about the computer, not a project. Project, Where, Source and Prepare are gone from it: nothing there is needed to get started. It is now This computer, Agent CLIs, Local model, Who does the work, What helps your agents (the same steps as Settings → Setup, embedded), then three specialists for every project: a Generalist, a Scribe and a Researcher, each with a name, a character, a runtime and a model, saved at the global layer. Finish lands on the Welcome screen with New project…; the specialists are already there for it. Settings → Setup has Run first-time setup again, which until now was offered only on the Welcome screen while no project existed.
All three specialists are saved, and they follow your default runtime. Saving three at once kept only the last: each save read the shared list of definitions, changed one entry and wrote the whole list back, so the writes overwrote each other, yet every one was acknowledged as saved. Those writes now take turns on the host. The first-start Agent CLIs step is the Setup wizard's own Runtimes step, which is where the default runtime is chosen (the old step had no way to), and the specialists and the starter team start on that default when it is ready instead of whichever CLI is first in the list. A computer whose Chat, Operations Manager and Worker already agree on one working runtime, and that has never chosen a default, gets that runtime as its default when the Agent CLIs step opens, with a line saying so; before, it showed Copilot because that is the built-in fallback.
Memory and merge conflicts take a model, once the CLI is signed in. Under Who reads the documents and a separate conflict agent there is now a model row. On a subscription runtime (Claude Code, Codex, Copilot CLI, Antigravity) it first asks you to sign in, because the models offered are the ones your plan lists; the same applies to each specialist's model. The memory model picker also understands "Default runtime", which it used to treat as a free-text prompt, and keeps the model on the computer when no project is open.
A first run opens with the left menu expanded and the bottom and right panes closed. The menu's labels are how a new person finds their way around, and the workspace gets the room; a pane opens when something asks for it or when you open it. Anyone who has collapsed the menu or opened a pane keeps it as they left it.
The Researcher shows its character in Research. A research conversation records who ran it as its team id, and the transcript only looked for a specialist id, so a research run by a specialist was drawn with a plain initial. It now finds the specialist from either.
Approving from the Inbox, a notification or the tray works. Those went to the agent's workbench as the desktop's own service actor, which a workbench does not know and treats as a remote client, so its policy refused the person's own high-risk approvals ("not allowed from remote clients") and an allow sometimes took several tries, while Mission Control worked. They now go as the person who pressed the button, as Mission Control always did.
The workbench's own read-only tools are no longer held for approval. Every MCP tool reached the policy as kind "other", so a read-only task_list or memory_search counted as medium risk and was held under an approval setting meant to stop only risky actions. Reading the board, the inbox, a conversation and memory, looking at a browser, and an agent reporting on its own task (task_start, task_done, task_blocked, ask_human) are low risk. Driving a browser, messaging other agents and changing the board or memory stay medium, and only the workbench's own server counts: its name is reserved.
Mission Control lists every agent in the repository. It showed only the current workspace's agents while showing everyone's approvals, so an agent could ask for permission and not be in the panel (a Researcher running a research, whose session carries its own name as its team). The current workspace's come first and the others say whose they are.
An approval toast's Open goes to the agent that asked, not just to Mission Control.
The log says why the app quit (a menu or tray Quit, the last window closing, a relaunch for an update or a space) instead of only "quit requested".
A research run that got no answer no longer files a "report". When the researcher's startup timed out (a 3-minute wait, here on an approval nobody had answered) the run appended its own error to the conversation and then filed that text as a research artifact: an 898-byte "report" of one error line, flagged for missing ## [findings] and ## [recommendation] sections. A report is now filed only when someone contributed or a final report exists, and a run that did not says "No report was filed" with what to check.
Research with a specialist runs it solo, like Chat. It started the specialist as a team of one, so its session carried the specialist's name as its team and its plan was filed on a board named after it (researcher.json) instead of the Solo board. A specialist's research now starts it the way Chat does, on the Solo board, and reuses that session on the next question. A research team or council is a real team and keeps its own board.
Quitting asks first when something would be lost. A menu or tray Quit, or closing the last window, asks "N agents are running / N approvals are waiting — Quit?" (Keep running is the default) when agents are working or approvals are waiting. Quits the app starts itself, such as a relaunch for an update, are not asked about.
The tasks a research run files can be found. A research run starts its specialist as a team of one, so its plan (T-1…T-3) is filed on a board named after the specialist, while the Tasks view's board picker hides specialists because chat with one is solo work on the Solo board. The tasks were on disk and unreachable, the ones waiting for review included, until you switched the board's backend to see them. A specialist that has a board with tasks on it now appears in the picker.
Setup works before any project exists. With no project open there was no workbench to answer the setup steps, so they could not load. The desktop now starts one on demand, on a folder of its own, for a window that shows no project, and stops it when nothing has asked it anything for ten minutes. It answers only the setup messages; a board or agent message from such a window is still dropped.
Setup → Runtimes offers to install the Claude Code adapter. A runtime found on the machine whose adapter is still fetched with npx on every first start (Claude Code, say) had no button in the setup wizard, although its note says installing the adapter skips that wait. It now shows Install adapter. A runtime that is fully installed still shows none there; Settings → Models has Reinstall.
One word for installing a runtime. Codex said "Set up Codex CLI" where every other runtime said "Install"; a runtime with nothing installed now reads "Install".
Specialists start with sensible approvals everywhere. A specialist made in any wizard (first start, Teams, Team Builder) cleans its worktree up on its own and auto-approves low- and medium-risk tools, asking only for high-risk ones.
Research writes OKF, Markdown and HTML by default into docs/research; Settings → Research still turns each format off.
Research tasks go straight to Done. A research run's own tasks no longer wait for your review. Turn on Settings → Research → "Review a run's tasks before they are done" to hold them in Review. A specialist set to wait for review still waits.
Choose which GPU runs the local model. On a laptop with an NVIDIA or Radeon card beside the graphics built into the processor, llama.cpp split the model over both, and the slow integrated GPU held the card back. The runner now asks the installed build which GPUs it can use (llama-server --list-devices), and Automatic runs on the discrete card (--device), the one with the most memory among equals. Settings → Local models → Engine and the setup guide show a GPU picker when there is more than one — Auto, each GPU with its memory, or all of them split — and say which GPU the model runs on. New setting localRunner.device; a device that is gone falls back to Automatic, and a --device in the extra arguments still wins.
Research builds prototypes, and hands them on. A specialist researches in a worktree of its own, on a research/<topic> branch, and may prototype the options it compares there; nothing of it reaches the checkout. A prototype with a screen is shown in the integrated browser: the researcher walks its user flows, keeps a screenshot of each step (browser_screenshot can now save a PNG into the agent's worktree with saveTo), writes the flows into the report as steps to try, and leaves the best option open in a tab. After each run the branch's changes are copied beside the report (<report>-prototype/: prototype.patch, the changed files, a README) and the report gains a Prototype section showing the screenshots. Send to Team Work gives the team the report and that copy (the patch to start from), then removes the research branch so the researcher can take the next question.
The Inference pane names the right machine. On Linux and macOS (and Windows outside WSL) it said "Start it on the Windows side"; the desktop app's own service serves every platform, so it now reads "Start the local model". Settings shows "Detect on Windows" for a local server only inside a WSL distro.
Memory → Find starts folded. Every group in the index starts closed, so a long one (Roadmap) no longer pushes the rest out of sight; the groups you open stay open.
Research follows the specialist's approvals. A research run started the specialist unlinked from its own approval settings, so it fell back to the chat defaults and asked about every read (conversation_read, say). Every specialist session now follows its specialist, and a specialist saved with no approval settings uses the specialist defaults (low and medium automatic, high asks) instead of asking about everything. What a research run does ask now shows above its own composer, not only in the side panel.
A long research run is not cut off. A research question had three minutes, like a planning prompt, and on the timeout its opening sentences were filed as the report. It now times out only after ten minutes with nothing from the researcher (never while it waits on your approval); a timed-out question files nothing and its turn is cancelled, so the conversation never shows done while the researcher is still at work.
One card per research report. A research run writes its report in up to three formats (OKF, a web page, plain Markdown), and each showed as a card of its own, in the conversation and in the Artifacts panel, with the header counting three. The formats are now a choice on one card: Open, Preview and Download act on the one picked (the OKF report first, since it opens in the Library), the card's menu still sends the report on, and the Artifacts count counts reports.
Stop an agent from the pixel office again. Selecting an agent in the pixel office offered a small × only for an agent with no role, so a team's members could be stopped from their cards and not from the office. The office now shows Stop on every selected agent (never a subagent), with the card's words, and both views stop through the one path: a stop pressed in either says "Stopping" in both until the agent has gone.
One Library entry per research report. A research run that writes its report as OKF, plain Markdown and a web page put three rows under Research in the Library, two of them tagged OKF. They are now one row, named by the OKF report's title, and the viewer has a Format switch — Web page, OKF, Markdown — that opens on the web page, else the OKF report, else the Markdown. The web page reads in the same sandboxed frame as before and is read-only there; the Markdown formats keep their front matter, outline, checks and editing. Opening a particular file from elsewhere ("Open in the Library") lands on the report's row with that format picked, and the Research count counts reports.
Agent worktrees are never nested, and the ones that hold no work are tidied. An isolated agent restored (or a specialist started) with its old worktree as its folder made its new worktree next to that one — .mojoup-worktrees/<repo>-<hash>/mojoup/solo/.mojoup-worktrees/researcher-<hash>/… — because the managed folder was worked out from the folder the agent started in. It is now always the main repository's. At start-up (and on demand with mjuWorkbench.tidyWorktrees) the workbench removes its own worktrees that hold nothing: under the managed folder, on a mojoup/ agent branch (not integration), with no agent working in it, a clean git status and every commit also on another branch. Anything else — uncommitted changes, commits found on no other branch, a research or feature branch, a detached review checkout — is kept, and the log says why. It never forces a removal.
An agent asks before writing outside its worktree. An agent with a worktree of its own that edits a file anywhere else (the checkout, another agent's worktree) is asked about it whatever its approval settings or mode, Full access included; the request is high risk and its title names where it writes. The system's temporary folder is exempt, and reads are never held.
Every run says where its work is. Research and Team Work end with a note naming each agent's branch and worktree, the files changed there, what is not committed and what is not on the checkout's branch yet, and any file it wrote straight into the checkout (only files its own tool calls named, so your edits are not blamed on it). A Chat turn notes checkout writes the same way.
The report a researcher writes is the report. A report the researcher wrote itself in the research folder (in the checkout, or in its worktree, then copied over) is linked as the conversation's report, instead of a second one written beside it from the chat reply.
A question is not ended by the agent's startup briefing. A research question sent while a new agent was still in its briefing listened from the start, and the briefing's own end (its cancellation by the three-minute watchdog) was taken for the answer: the run closed with "no answer", and the agent then worked on the question with nobody listening, so its approval requests reached no conversation. The question now waits for the briefing. A request the agent makes during the briefing that the approval policy does not let through within two seconds is declined (the briefing does no work) instead of holding the agent, unseen, for three minutes.
One agent per specialist on the Solo board. Chat started a specialist per conversation and research started another, and after a restart a restored one was forgotten, so two Researchers could stand side by side with one waiting on an approval nobody could find. A chat with a specialist, its research and its tasks now all go to the one already running there (restored ones included, with the specialist's approvals); a restore brings back one of each. Only "Ask several…", which asks another model on purpose, starts a second.
Source Control knows research branches. A research/… branch read as "external, not created by the workbench"; it now shows as the research conversation that made it. A prototype's packages are installed in its own folder only, never system-wide, and the report says what was installed.
Research asks you as it goes. A researcher is told to ask (ask_human) when something only you can settle would change the answer, as soon as it comes up, instead of listing it under Open questions at the end. The run waits for your answer, gives it to the researcher and carries on to the report; Stop ends the wait. The question shows above the Research conversation's composer (it looked on the specialist's own board, where nothing is filed). An answer to a question from an agent on the Solo board now reaches it: the lookup expected a team name those agents do not have, so the answer was never delivered.
Research ends on a card. A research run closes with one "Research done" card in the conversation: the report with Open; the acceptance criteria of the plan the researcher made, each with its evidence, to pass or fail right there (or close the plan anyway, with a reason); and Send to Team Work, the same as the header's button, which then shows that it went. When the plan's work is done its UNIFY is asked for at once — closed when every criterion passed, held for your verdict otherwise — where before a research plan stayed open for ever unless you found it in Plans.
A window that gives out says so, and comes back. A window's page dying (a renderer crash, the GPU process, out of memory) or hanging left nothing in the log, so a window that vanished mid-run read only as "the last window was closed". The log now records why a page went, when it stops and starts responding, and every window close; a page that died is reloaded instead of leaving an empty frame.
Ctrl+W no longer closes the window on Windows and Linux, and quitting asks while agents work. Ctrl+W (Close Window, also brought by the menu's "close" role) fired from a text box or the terminal, where it means "delete the last word", and closing the only window quits the app: it went mid-Team Work, tray icon and all. Close Window stays in the menu without a shortcut; macOS keeps Cmd+W. The question before quitting now asks each host how many agents it has at that moment instead of trusting its last status frame, which had let a quit through with a team running.
No more "merge-back failed" for a branch that is gone. Approved tasks whose branch was deleted (its worktree tidied away) were retried on every backoff for ever, each attempt a warning. A held merge whose branch no longer exists is now dropped once, with a line in the orchestration log, and the merge itself says there is nothing to merge instead of failing.
A restarted agent's old processes are really gone. Stopping an agent signalled its process group, but returned as soon as the agent itself exited, so a child that ignored the signal (an MCP sidecar) lived on and called the workbench every five seconds on a revoked credential. The kill now waits for the whole group and forces what is left; and the task-board sidecar stops watching for tool changes once its session's access has ended, instead of retrying it for as long as it runs.
Source Control's Worktrees and Branches fit the card. Their rows were table rows that could not shrink: the actions (Merge, Open PR, Push, Open, Switch, Delete) and the worktree path ran off the right edge with no scroll. Each row now wraps: the path or commit subject truncates (the path from its start, so its end shows; the whole of it is the tooltip) and the actions drop to a line of their own when the card is narrow. The Branches tab's badge, which counts work waiting to land rather than branches, says so on hover.
The conversation keeps its room while you answer. What sits above the composer (an agent's questions, the brief, the plan, the tasks) now takes at most 45% of the window and scrolls inside itself, and the question cards have Hide, which shrinks them to one line ("Ben asks …") until you want them again; the composer still answers the first.
You are told when an agent asks you something. A question raised no notification while its conversation was open in the window, even with the card below the fold or the window behind another app, so only approvals ever reached you. A question is now announced as an approval is, and neither is held back because the window is merely visible: one behind another app counts as not being looked at.
No phantom "Needs approval" while an agent starts. A request an agent made during its startup briefing that the approval policy answered at once left the agent showing Needs approval, with nothing anywhere to approve, until the briefing ended: the briefing keeps "starting" on the agent and ignored the change that ends an approval wait. An answered wait now goes back to "starting".
Steps say which command and which page. A tool call's first title is often only the tool ("Terminal", "Fetch"), so Chat, Research and Team Work showed "Ran a command" and "Fetching a page", and Mission Control and Agent history the bare tool name. The agent manager now puts what a call acts on (the page, the search, the pattern, the file) on its events beside the command it already carried; a step reads "Ran npm test" or "Fetching conductor.build", with the whole line when opened, and a later update that brings the full title fills the step in.
A specialist keeps its approvals across a context reset or restart. Both give its session a new id, and only a Chat conversation's binding followed it, so a reset Researcher fell back to the chat defaults and asked to approve every page it fetched. Its approvals, its research run and its place as the specialist's one session now follow the new id.
A researcher's own report gets every format you configured. When the researcher wrote its report as a Markdown file, only that file was linked. Every format in Settings → Research is now made from it, beside it under its name (OKF in its place, the whole report inside), so the Library lists one report and the reader switches between them, web page first.
A fresh install lays the panes out the way they are used. The bottom dock holds the machine (Terminal, Usage, Inference, Updates, Notifications) and the right sidebar the work (History, Mission Control, Files, Editor, the graph), in that order. A layout you already arranged is kept.
Auto-approved requests no longer flash up as cards. Every request is written down as it arrives and the approval policy answers the ones it allows a tick later; the list of open approvals went to the window at once, so each of those appeared above the composer and vanished. The list is now sent a moment after it changes, by when those are answered and gone; one that waits for you appears as before.
Notifications know where you are. An approval or a question no longer pops up (in the app or as a system notification) while you are looking at it: the window focused on the conversation the agent works in, or on that agent in Mission Control. It is announced the moment you look away while it still waits: another view, another conversation, another app. Approvals used to notify even with their conversation open, and anything held back was never announced later.
A research run that fails still files what the researcher wrote. A researcher that wrote its report into its worktree and then hit a usage limit left the run with no answer, and the report stayed on the research branch: one format, reachable only by an external editor (a file outside the checkout opens there). The research branch is now collected however the run ended, so the report lands in the research folder in every configured format and opens in the Library.
Mission Control lets you pick an agent again. Opening it on one agent (from its card, or a toast's Open) was re-applied on every sessions update, so with any agent at work it snapped back to that agent and no other tab could be chosen. The request is now applied once.
Research branches are never merged. A research run's own plan tasks, on finishing, went through the ordinary merge-back, which merged the agent's current branch — the research branch — onto the integration branch on its way into the base branch: prototype code, the report and all. A research/… branch is now refused by every merge-back and dependency merge; its work goes on beside the report as designed.
Toasts keep their button, and say it once. A toast's action is no longer pushed off the edge by a long message (the toast wraps), and "approved commits are waiting to land" no longer repeats its own sentence.
The Library's Page / Source switch is the sidebar's segment. It uses the same sliding control as the colour mode switch at the foot of the sidebar, with an icon beside each word, instead of two detached buttons.
The browser's + opens a tab while a blank one is open. Opening a tab fills an untouched blank tab rather than starting another (right for an agent opening a page), so + only showed the blank tab again and a second tab could not be added until the first had a page in it. + now always opens a new tab.
Views pop out into windows of their own. Tasks, Plans, Roadmap, the Office (agent cards and the pixel office), Watchlist, Pipelines, Operations, Memory, Decisions, Library and Architecture have an "Open in a window of its own" button beside the view's name in the title bar. The window shows just that view, on the project it came from (a project switch in the main window leaves it be), named "Tasks — <project>"; one per view, so a second press brings it forward. Links inside it to the same view stay there; links to another view open in the main window, which comes forward, and a file opens in an editor window. The browser dialog has the same button: its tabs move into the new window and come back to the main window when it closes, and agents keep driving them throughout.
On Linux, closing the last window leaves the app running in the tray, as on Windows, so agents and schedules carry on. Quit from the tray menu; Settings › Close to tray turns it off.

0.46.3

Install buttons ask for your password in the system dialog on Linux. The setup guide's Install buttons (Git Credential Manager, Git, the OpenSSH client, starting Docker) ran sudo in a terminal pane that could sit unseen while sudo waited for a password. They now use pkexec where it is installed, which shows the desktop's own password prompt. Git Credential Manager installs through apt, so its dependencies come with it.

0.46.2

Checked on native Ubuntu. The .deb and AppImage build and all three test suites pass on Ubuntu 26.04; no changes to how the app behaves.

0.46.1

The Watchlist's workflow picture starts folded into a one-line tile: Show the picture opens it, Hide the picture folds it again, and your choice is remembered.

0.46.0

The Watchlist's workflow, plain. An opened entry starts with where it is — a risk Identified, Assessed, Treating, Monitoring, Settled; an issue Open, Working, Resolved; a bug Open, Fixing, Fixed — and a Next step card with the one thing to do: assess it, decide what to do, assign the treatment or accept it, see who is working on it, rate it again, mark it reviewed.
Settle… asks how it ended, in words: Resolved, Accepted (with a reason), It happened (raise the issue), No longer relevant; a bug Fixed, Won't fix or Duplicate. Settled entries say how, by whom and when, and can be reopened. One line tells who answers for a risk from who does the work.
A picture of the workflow heads the Watchlist, with how many entries sit at each step. Press a step to see what it means and who does it; Show me filters the list to it.
A proper tags field: chips, Enter or a comma to add, suggestions from tags already used; the Watchlist filters by tag.
The open project's repositories in the switcher, above the projects: which is running, which machine it is on, and Ctrl-click for a new window.
The Watchlist no longer names the product its risk model came from.

0.45.0

The rings, two ways and a second picture. Nine tiers as before, or five themes — Direction, Governance, Structure, the agent's kit and Memory — with a tier an arc of its theme's ring. Quiet at rest; the ring under the pointer wakes up. Opening a group keeps the whole picture: the other rings become a rim, the group's children fill a wide ring inside it, split into arcs by status, folder or family, with counted links to the rim, as deep as the hierarchy goes. Shelves show the same hierarchy as rows. A View pill beside Explore switches, and remembers.
Still while you read. The rings' sweep and the centre's breath pause while the pointer is over the picture or anything is open.

0.44.0

Chat history shows each conversation's kind, and selecting is in plain sight: tick on hover, selection mode, and a bar to archive, group or delete several at once.
The @ picker opens whole above the composer in Chat, Research and Team Work.
Stop an agent from its card in the office's card view, and Stop and discard for a stuck one.
A projects-only switcher in the title bar, with search, Add project and All projects.
Source Control's colours mean something: red needs you, amber has work not committed or pushed, green is clean; merge conflicts count as needing you.
Rating a risk is plain: Overall or By dimension, and "Follow the controls" shows its working. Names stored without a space are tidied.
Agents use the Watchlist and decisions: every agent can raise risks, issues and bugs and propose decisions; reviewers raise bugs; new routines for a weekly risk review, harvesting decisions and lessons, and bug triage.
Routines at scale: list, grid and by-project views with search, filters and sort.
Daily reviews you can clear: Done and Dismiss fold away, with Undo and Move back.
Governance and Library rings in Memory, and tracing a link to the exact item it points at.
Fixes: the Memory view no longer says the engine is installing while it only checks it.

0.43.0

Undo a turn. Every agent turn in its own worktree is snapshotted. Chat shows what each turn changed, and Edit from here takes the conversation back to before a message, with or without its file changes. Fork a reply into a new conversation; re-run a Research report another way; quote a passage into your reply. Chat work now merges after ten quiet minutes or when you say Keep it.
Sending while it runs. One send button: Interrupt, Steer or Queue, Resume, Launch or Refine. A queue you can reorder and edit, kept across restarts; ↑ recalls what you sent; Ctrl/⌘+S stashes a prompt. Approvals and questions dock above the composer.
Where Chat runs. Choose this checkout, a worktree of its own or the last one, and the branch it starts from; agent, model, thinking and access sit in the composer. A context meter with Compact, and banners for usage limits (Resume at reset), sign-in and branch drift.
Turns at a glance. A finished turn folds into "Worked for 2m 14s"; tools read as sentences. Long conversations open fast and page in older turns; a minimap jumps between turns.
Permission modes. Supervised, Auto-accept edits, Auto or Full access per agent, capped by policy. Approvals are written down, survive a restart and are answered once.
Ask several. One prompt to two to four specialists or models, compared side by side.
Switch agent mid-conversation with a handoff that carries the conversation.
Your subscriptions. Your own Claude, ChatGPT, Copilot and Google subscriptions, each used only by its own vendor's runtime, in your own profile on shared nodes; sign in on a node from the inbox. Several signed-in accounts per runtime, chosen per member.
Team Work undo. Revert a task's changes or run it again, from the task or the conversation.
Pull requests from GitLab, Forgejo, Gitea and Bitbucket; a merged pull request closes its task.
Nodes install in one command and update themselves safely, rolling back a version that does not start; an out-of-date node or desktop says so and offers the update.
Desktop updates install in place on Linux and follow a stable or nightly channel.
Security. Organisation sign-ins bound to this device's key (DPoP); paired remote clients expire when unused; every Control API method needs its scope.
Fixes. Research shows its progress as it runs; Chat shows a reply's thinking; Retry keeps attachments; each conversation keeps its own draft; the project switcher no longer overlaps long names.

0.42.2

The live monitor's Machine tab reads the hardware again when there is no local model on this computer, or the desktop's service runs it. It used to wait on "Reading the hardware…" for ever; model figures still appear when a model is running.

0.42.1

Quick runs on Home. Pin any routine, or make a new one with no schedule, and run it from Home on both All projects and This project; each card says what it does, where and who runs it, and how its last run went; routines you already run by hand are suggested.
Chat history you can organise. Filters (kind, status, who, date, artifacts), an Active toggle, search through message text, named and coloured groups, archive (one or many, or after days idle), and Delete now asks first.
Library and Memory show what they are waiting for. The tree, documents, pages, templates, rings in every scope, the centre panel, Look it up, project notes and the first memory build; buttons that are working say so.
A simpler Watchlist. The scale is "Standard 5×5" with no standard's name in the way, and the Metadata tab is one line under the form.

0.42.0

Home across every project. An All projects dashboard: what needs you, agents at work, routines due or failing, spend, and a card per project; Run now for routines; Routines across every project.
An Inbox. What needs you — approvals, decisions, escalations, held landings, updates, sign-in — grouped by organisation, project and repository, with Done and Snooze; Notifications is a quiet log.
Projects at scale. Detailed, List, Grid and By machine views with search, filters and sort; rename a repository; open any project in a new window (File → New Window); "Find it again" for a repository whose machine or folder is gone, moving several to a new WSL distro at once.
Setup without assumptions. A local model is optional; memory, merge conflicts and data protection explained in one step, none defaulting to a local model; choose any runtime as the default; llama.cpp follows the newest checked release; MLX detected on Apple silicon.
Kilo Code as an agent runtime, with its usage and cost.
Settings for a meta harness. Plain words, no editor-era leftovers; change a setting for this workbench, this machine, the project or the repository, with overrides you can undo; what your edition allows.
Watchlist. Risks, issues and bugs on the ISO 31000 5×5 standard: inherent and residual assessment, controls, appetite, heatmap and list; assign any item to a team or specialist; status reports carry a Watchlist section.
Decisions. A register filled from the roadmap, plans, answered questions and ADRs; agents are told the decisions that bear on their work and warned off what was already decided; a Decisions ring in Memory.
Architecture shows the organisation's reference architecture, standards and templates; the Scribe can follow a template; Open on the map lands on the thing.
Source Control for the whole project, organisation teams from the Teams view, copy any message, timelines rebuilt for work before the run log, and a clearer Teams header.
Graphify per its own guidance. One pinned engine per machine (old copies cleaned up), broken installs repair themselves, secrets and runtime files kept out of the graph, code-only updates between scheduled document reads, backups trimmed, and sharing the graph in git as a choice.
Fixes. CI green on Windows, macOS and Linux again; several waits that could hang or race.

0.41.1

Code blocks readable in dark mode. Plain-text boxes in the Library (and anywhere the Glass theme draws a code block) were dark grey on dark; they are light now.
Show on the map shows the links. A memory answer lights every result on the rings and draws how they connect, and to what, with everything else dimmed; pressing one result draws its own links and opens its details. Clear or Escape puts the rings back.
A new mark for the node. mojoup-node opens with the icon's circle and cube drawn as an amber outline in quadrant blocks, which the terminal draws itself, so it is clean in Windows Terminal and any font. On a terminal too narrow for it the banner is the three text lines alone.

0.41.0

Reports read as pages. Retrospectives, status reports, research and pages agents make open in the Library as designed pages, light and dark; Page / Source switches to the file; save as HTML, PDF, Markdown or OKF. Research pages number their sources and list them as references. Scheduled status reports land in the Library under a dated name.
Retrospectives that teach. What went well, what did not, and what we will change, from the board, reviews, timeline and risks; agent notes shortened to one line each. Act on any item: make a task (choose who does it and whether it lands on its own, as with the Scribe), add a line to Team guidelines, or keep it as a lesson agents read when they start. Opened from a card on the plan.
Timeline cards. Runs, agents, run time, tokens and cost as cards.
The rings' centre shows the architecture's own summary and only a real vision, as formatted text with Read more.
Architecture loads again on repositories whose descriptions grew long: one long description no longer drops the whole picture; it is shortened and flagged.
Credits. pixel-agents (MIT) and Graphify (Apache 2.0) now show their licences.

0.40.0

Rings are the Memory picture. The rings replace the old repository graph, with a switch for this repository, the whole project or your organisation. Explore opens them full screen with connection filters, zoom and the most-connected list. The Applications ring is now Tools.
The centre says what it is. Press the AI Workbench mark in the middle for what the repository, project or organisation is and where it is going, with when and by whom each was last updated; when nothing is written, ask the Scribe to write it. The Roadmap and Architecture views say when they were last updated too.
Your organisation, within your access. Organisation rings show your projects, the organisation's skills and tools and its memory topics. A personal project's agents can ask the organisation's knowledge as you; your project's memory still stays with you. Project notes say where a project's memory is kept.
Built-in engineering skills. Debugging, test-driven work, codebase design and prototyping skills (from Matt Pocock's skills, MIT) come built in. A team member's chosen skills now limit what it sees, and each team can have short Team guidelines.
Reviews, retrospectives and pull requests. Reviews report the repository's standards apart from the verdict; retrospectives propose fixes to how the team works, which you can turn into tasks; a pull request from a plan says how risky the merge is.
Who is stuck. Agents show Waiting for you, Stuck, or Finished, not yet reviewed; every finished task says why it closed; a handed-off task nobody picks up is chased, then passed to the team lead, then to you. Agent cards warn when an agent's context is nearly full, and automatic messages wait while you are typing to that agent.
Plans with care. Plans are cut into slices one agent can finish; shaping asks one decision at a time with a recommended answer; each plan step can be Quick, Standard or Careful; the roadmap keeps a list of rejected ideas. After a context reset an agent gets a short recap, and plan changes reach a running agent on its next turn.
The Library. Retrospectives, reports and artifacts have their own group, Open in the Library lands on the file, the file pane can be widened, templates are named by their front matter, documents and templates can be deleted, and your organisation or team can publish templates.
Faster, clearer loading. Source Control shows your branches before it checks the remote, and slow pictures show what they are loading, with Retry when it fails.
Fixes. Team dropdowns no longer cut off their values; a personal project's "Ask the organisation" asks the organisation; Plans no longer says "No plans yet" while loading.

0.39.0

Full screen. Architecture (the picture and "About this picture"), the Library, Timeline, Roadmap, Plans and Tasks have a full-screen control; Escape leaves it.
Back up and restore, and move machines. Settings → Back up & restore keeps your settings and each repository's chat history, plans and runs, matched by repository rather than by folder, so a restore onto a new WSL distro or a moved folder finds them again and only asks when unsure. Backups run on a schedule; signed in to your organisation, it keeps a copy for you. A repository that moved keeps its history.
Projects in your organisation match the workbench. A repository's committed project file now follows the project you put it in, so old personal projects stop coming back, and the ones you no longer use are offered for removal.
Acceptance before Unify. A plan waits for you to pass or fail its acceptance criteria before it closes, or to close it anyway with a reason. A plan closed with criteria unmet says so.
Plans that span repositories run there. A part of a plan for another repository goes to that repository's team and starts; work that depends on it waits, and the plan waits for it before closing.
Project memory. Agents are steered to the project's memory when a question crosses repositories, the planner reads it, and queued memory writes survive a restart. The Memory view lists the project's notes, lessons and decisions per repository.
Rings with depth. The Architecture and Roadmap rings in Memory show their top level; click a node to open what sits under it, with a breadcrumb and Back.

0.38.2

"Land it automatically" lands. A scribe task you asked to land on its own no longer waits in Review because the agent asked for a look, or because it finished with a text marker. Only work finished with concerns still waits for you.
Review buttons read as they are. Approve is the solid button; a line says why Request changes needs your feedback first.
Open in external editor on Windows no longer fails with "spawn … code ENOENT": the workbench runs VS Code's code.cmd, not the script beside it.

0.38.1

Your Copilot instructions file stays. Removing old graphify skill copies no longer deletes .github/copilot-instructions.md when graphify's section was all it held: that file is Copilot's instructions for the repository. Only the section is taken out, and only when the file holds other instructions too.

0.38.0

Open in external editor works again. From the Files pane and the editor's toolbar it now opens VS Code (or your chosen editor), including files in WSL. It had been opening the built-in editor.
Sandboxed nodes. A Linux node can run each agent session in its own NVIDIA OpenShell sandbox, with the network rules enforced and API keys kept out of the agent's reach. The node checks at start whether the machine can, and says why not. This needs a run on a native Linux node before it is relied on.
Routines on a node. A routine for a repository on a node is saved and run on that node; the Routines list says where each one runs. mojoup-node routines lists, runs and removes them.
Plans say what they produce. A brief asks whether the work should produce a document, changes, or both. A plan step can name the document it delivers, and an agent cannot approve the step until that document exists.
Memory. Lessons are kept as one item per repository at the project's home, a node only shows a peer what its clearance allows, and search finds "ledger" in a name like BillingLedger.
Fewer secrets on disk. Two access tokens moved out of the repository's .mojoup/ folder, and agents no longer inherit the workbench's own credentials. Hosted providers go through the local proxy, so agents get a stand-in key.
Smaller things. Publish a skill to your team from Settings → Skills; download artifacts from SSH and node machines; one artifacts panel in Research; the blocked-work routine comments on the project tasks it chases; risk dots on the roadmap board; a renamed project's new name reaches your organisation.

0.37.0

Risks and issues. A new Risks view keeps what may go wrong and what has, for a repository or the whole project, with a rating, an owner, a response and what each one threatens. Roadmap items and tasks it threatens carry a dot; a blocked task can raise an issue in one step; agents can read and raise them too.
Timeline. A new Timeline view shows when each agent worked, on what, for which plan, task and roadmap item, and who set it going: you, another agent, or a routine. It also appears in Plans, Roadmap, Tasks, Mission Control and the office.
Retrospectives and status reports. A finished plan gets a retrospective, and a status report covers a repository or the whole project over a week or a month. Both are Markdown or OKF from a template your repository can change, made by hand, by an agent or by a routine, and saved to the Library.
Artifacts. Chat, Research and Team Work list what a session made — a report, a document, a diagram, a table — with Open in the Library, Preview and Download. The composer's new "Make" choice says whether you want a document or changes to the project.
Secrets. Settings → Secrets keeps the keys and tokens your tools need, for this machine, the project, a repository or your team, and shows what each repository asks for. Your organisation can keep them too. Agents only see a secret that says they may; everything the workbench keeps is masked for credentials.
Tool servers. Settings → Tool servers shows every MCP server agents use and how it is governed. When your organisation asks to be asked first, an agent's tool call waits for you with Allow once, Allow for this task or Refuse.
Where agents may connect. Your organisation's network rules now apply to the built-in browser's pages and to tool servers reached by address.
Routines for the whole project. A routine can run for the whole project, with five new project templates and a weekly status report. The list says what each routine belongs to.
Ask the Scribe, whole project. It now asks whether to land the change or hold it for your review, and describes every repository first, so one ask draws the whole project.
A tidier board. Scribe and routine tasks leave the board an hour after they finish, done tasks after 14 days, and the Done column shows the latest eight. An agent's name on a card is no longer cut off.
One memory skill. The workbench no longer writes a graphify skill into your repository's .github and .copilot folders. Agents get a built-in memory skill instead, and your organisation or team can publish its own. Copies earlier versions left are offered for removal.
Renamed. Documents is now the Library, and Git is now Source Control.

0.36.1

Project memory now fills. On some repositories the new project memory never received the repository's knowledge, and the log showed an error every minute. Fixed, and a large repository's memory now goes in in a few seconds instead of half a minute.
Plans has a Whole project level too: every repository's plans together, each step with its task's state, a step done in another repository named as such, and the project task a plan across repositories rolls up into.
Ask the Scribe on the project roadmap and the project architecture: it groups the repositories' roadmap items under project items, or works out the layers and the connections the code shows, and merges its work into what you have drawn.
Promote a note for the whole project, in any project: Memory → a note → Promote, then choose this repository's part or the whole project.
Connection lines in the project architecture go around cards, keep apart when several run the same way, and their labels no longer sit on top of each other.
A node says which parts of project tasks are waiting for a repository to start, and names the person it works for when its agent sends part of a project task elsewhere.

0.36.0

A project has work of its own. Above each repository's roadmap, tasks and architecture there is now the project's: Roadmap, Tasks and Architecture each have a This repository / Whole project switch. Home shows the project's progress, its open tasks and what happened lately.
Project roadmap. Items for the whole project, each delegated to items on its repositories' roadmaps. An item shows what those add up to, and you can still settle one by hand.
Project tasks. A project task is not worked directly: you send parts of it to repositories, each part becomes a task on that repository's board, and the project task rolls up from them. A repository that is not running gets its part when it next starts. Your inbox says when every part is done, or one is blocked.
Project architecture. How the repositories fit together: layers across repositories and the connections between them, with suggestions to start from.
Project memory. Every repository adds what it knows to the project's memory, so a question about the whole project is answered for a repository that is not open. An agent can keep a decision or a lesson for the whole project.
The same in every edition. A personal project's records are kept by this computer; one shared with your team by the team's hub; an enterprise one by your organisation. Sharing a project takes its roadmap, tasks, architecture and project memory with it.
Who did what. Every change to a project's roadmap, tasks and architecture is signed with the person it was for and the agent that made it, and listed in the project's activity. Settings → General → You sets the name and email your work is signed with. Two people changing different roadmap items at once both keep their change.
For agents. New tools read the project's roadmap, tasks, architecture and activity, add a project task and send parts of it to repositories; a plan can place a task in another repository of the project, and then rolls up as one project task.
Nodes keep the records of projects that are their own, and an agent on a node sends part of a project task to another repository for the person it works for.

0.35.8

Your policy caps remote control. A repository's rules, or your organisation's, can say which ways in are allowed, how much a paired device may do, that connections must be encrypted, and that remote control stays off. The Remote control card says which rule limits it and whose it is.
Small local models pay only for the tools they need. An agent sees the task-board tools for its role and the phase it is in, and can ask for more; a worker on a local model carries about a quarter of the tool text it did.
Reduce effects on Settings → General turns off the moving background shapes and other decoration.
A new README for people deciding whether to install.

0.35.7

Transcripts leave the repository. Session transcripts and the chat history now live with the workbench's own data, copied there on first start; the old folders keep a note saying so. The task board and routines stay with the repository.
Which team? When several teams run and a request names none, the workbench asks instead of picking the first one. Memory updates after approvals are gathered into one a minute.
One picture of every model. What a model can do — context, tools, vision, thinking — comes from one place: your own tuning first, then what the local runner measured, then the catalogue.
In the chat, tool calls, approvals, attachments, sources and the working state use the chat's own parts; every Teams form and the setup wizard use proper controls with steppers.
Every view says why it is empty and offers the one thing to do; no text is smaller than 12 px any more.

0.35.6

Agents that recover on their own. A check-in reaches an agent whose turn is stuck; an agent that crashes is restarted with a pause between tries and then left stopped with a note in your inbox; an approval nobody answers is allowed once (low risk) or refused (medium) after a set time, and the inbox says how long is left; a turn cut short by the model's limit is asked to carry on. Settings under Agents and Approvals.
Started from a launcher, the workbench sees your shell's tools. On macOS and Linux the host picks up the PATH your terminal has; in WSL it waits for it before starting. A saved Ollama or LM Studio address that moved with the Windows host IP heals itself.
Quieter and reachable. Views refresh on what the host tells them instead of polling; every icon button has a name and a hint; focus stays visible in lists; dialogs and the command palette take focus, close on Escape and give focus back.

0.35.5

A team member can run on another person's workbench. When a member's Runs on names a workbench your organisation or team hub knows, pressing Start sends it there; that workbench starts it for you and its owner sees "started for <you>" in the inbox. The member card says "running on <machine>", or why it could not start. A node starts a member on another node the same way. The hub keeps what it knows about nodes across a restart.

0.35.4

The team hub, rounded out. A node can be the hub (mojoup-node hub); a member placed on a node the team paired is started there through the hub; the team's memory and pull requests live on the hub; the hub uses this machine's Tailscale name and certificate when Tailscale HTTPS is on, so a phone can join it; Settings → Team says where it was reached and where the team's rules came from. The Memory view asks the team on a hub.
Every machine tells the organisation which settings it runs, so the console's rules editor can warn when a key is unknown to a machine.

0.35.3

A team hub, for the Teams edition. One workbench on your team's own network (Tailscale or a VPN) becomes the hub from Settings → Team: it shows its address and fingerprint, invites people with a short code, lists their workbenches, nodes and phones, approves a node that asked to join, and publishes the team's rules. The others join with the invitation line, and the hub's certificate is checked before anything is sent. A project shared with the team gets the shared board, one inbox and members placed on the team's nodes, without an organisation account. mojoup-node join --hub does the same for a node.
The project map, mirrored. On an enterprise project the organisation's console can now draw each repository's plans, architecture and roadmap; the workbench sends them when they change.
Remote control can bind your tailnet address and, off this computer, makes itself a certificate; the Remote control card shows the address to pair with and the fingerprint.

0.35.2

The organisation's memory, from here. Agents and the Memory view can ask the organisation's own memory and every project you may read, each answer saying where it came from. On an enterprise project you own, keep its knowledge mirrored into the organisation's memory, or share everything readable once.
A project's budget is honoured. When the organisation pauses a project for budget, nothing new starts and the inbox says why; when it blocks one, running agents stop at the end of their turn. Lift it for a day from the inbox, with a reason. Home shows what the project has spent this month.
Signed in stays signed in. The desktop no longer signs itself out at start, and Runs on lists the nodes and workbenches you may use, with a search when the list is long.

0.35.1

From the first on-screen pass of 0.35.0, and what followed it.

Edit a project anywhere. One dialog for a project's name, colour and repositories — add one, move one to another folder (it keeps its board), remove one (the folder stays) — from each card on Projects, from Home's header and from the project menu. The organisation's projects are back on the Projects view.
Runs on. Each team member says where it runs: this computer, a node your organisation assigned you, or any node with the tags you give, with a fallback when no node can be had.
The organisation's rules cover every setting. A setting the organisation locks reads "Set by your organisation" and cannot be changed here; one it sets as a default can. Nodes follow the same rules for their own settings. And an organisation that has published no policy never replaces the repository's own policy file again.
Sent from the organisation. A task sent from the console's Work tab starts here, and its card says whether it was sent, started or refused.
Quiet hours, quiet days and muted projects for the inbox; an approval asked of you by name still reaches you.
Switching repository keeps the window instead of reloading it.
Memory, labelled. What goes to the organisation's memory carries the project's labels; what an agent writes back carries the sensitivity of what it read; a member's vault gets an Organisation folder rendered under their own entitlement.
Nodes kept in step. A node's repositories know their project, an approval that reached your phone is held for you, and the node's status shows what it holds.

0.35.0

Home. A project Home is the landing view: what needs you, what is running now across every repository (and whom each agent works for), the repositories with their machines, the team, the project's standing with the organisation (promote from here), pull requests and memory across the whole project. Every repository view says which repository it is on; the switcher leads with the project.
One identity. A project has one id everywhere — the organisation, every repository's committed manifest, every workbench — and each repository one id; the desktop registers every project with all its repositories on sign-in. Linking a repository no longer forces its siblings' boards; a promotion switches the board in place.
The inbox. A bell and a Notifications pane: approvals with Allow and Deny, questions, turns done or failed while you were away, tasks ready for review, policy consent, routines, updates, pull requests — one line per thing, answered from the pane, synced with the organisation so the console and the phone show the same inbox (an enterprise project's is the organisation's; a personal project's is mirrored there).
Memory belongs to the project. Agents ask every repository of the project; on an enterprise project the organisation's memory service is the index of record, fed after every extraction and read back through Organisation mode in the Memory view.
Teams belong to the project. Specialists are found by id, the organisation's rules decide which teams may run on its projects, its catalogue leads the team wizard, tasks on a shared board are claimed before an agent starts, and members are placed where the organisation says — a member placed on a node starts there.
Pull requests as part of the work. Joined to the task, watched into the inbox (your review asked, checks, conflicts, merged), review comments turned into tasks for the member who did the work, a specialist asked to review, the organisation's merge rules applied, every pull request fed to the organisation.
Nodes you can see. Who is attached to a repository on a node and whom each agent works for; a node's git credential follows the agent's worktree.
Plain words everywhere. Repository, machine, node, project, team, specialist, organisation, business area — never root, target or workspace; Settings → Project and Organisation pages; the duplicate Platform card and the scattered repository controls are gone.
Usage attributed. Every usage record names the person, the agent, the repository, the team and the task.

0.34.26

Weekly roadmap refresh routine. A new template on Operations → Routines, and a new action in the routine editor: the Scribe brings the roadmap up to date with the code and the board once a week, and its changes wait in Review for you.

0.34.25

Work a specialist was told to land on its own is merged. Approval merged into the active team's repository, and a specialist working alone has none, so the task said "done" while its commit stayed on the specialist's branch. It now merges into the root's own repository, with the branch found from the specialist's session.

0.34.24

Asking the Scribe to update the architecture fills every layer. The map treats a plain match entry as one area exactly and folder/* as everything under it, but the Scribe was told "path prefixes", so areas below the folders it named fell into unnamed layers with no description, however often it was asked. Its brief now states the rule, lists the areas that fall outside every layer, and asks for a description of the docs, config and tests layer.

0.34.23

Open an AIOE project without a node. The Projects view lists your organisation's projects. "Add to this workbench" clones a project's primary repository (from its Source in AIOE) and links the new root to the project, so it counts as that project here and uses its shared board from the first start. A project with no repository recorded says where its owner adds one.
A quieter roadmap toolbar. The status cards are the status filter (a card shows when it is on), series is one dropdown, the layout switch is two icons, and Sequence with AI sits beside search.

0.34.22

Roadmap: a board to prioritise and sequence. A Board layout beside the list: one column per phase, the items still to do as cards in priority order. Drag a card (or press Alt and an arrow key) to reorder it or move it to another phase, and the roadmap file follows. Items can wait on others: "Waits on" in the item dialog, a "waits on" badge, "holds up" counts, the critical path and any loop that can never finish. "Sequence with AI" asks a specialist for the order, phases and dependencies with a reason for each step; you accept all or some.
Roadmap vision on the page. A Vision card opens the whole vision, where it is kept, and how to change it.
Organisation projects. A root onboarded to the platform registers its project with AIOE as a personal project; its owner can promote it into a business area from Settings → Organisation, see it waiting, and withdraw it. An enterprise project's roots use the organisation's shared task board (the first to share it brings its tasks along), and "Add to this workbench" clones an enterprise project you are a member of. Teams AIOE grants to the project appear read-only.
The task board can be shared. Under the board sits a store that is either the root's files or the organisation's board, with versions, a live feed and nothing claimed while AIOE is out of reach.

0.34.21

A wizard closes only when you close it. A click outside the roadmap wizard threw away everything typed into it, and every other wizard did the same. The project, team, roadmap, roadmap item and routine wizards now ignore outside clicks and Escape; only their close button or Cancel ends them. The pipeline run and approval dialogs, the pull-request review, the path prompt and the text prompt ignore outside clicks too.
Hand the roadmap to the Scribe. Like the Architecture view: "Ask the Scribe to update it" on the Roadmap view, and the wizard's last step, file one scribe task and start it, and you choose whether the finished roadmap lands on the default branch by itself or waits in Review for you.

0.34.20

The mesh finds its way back to a direct path. A peer that fell back to the relay during a network drop stayed on it for good, even two agents on the same PC. The mesh agent (7850663) now offers a relayed peer its direct addresses again after 30 s, backing off to 15 minutes while none holds, and WireGuard's roaming keeps whichever path works.
A relayed peer is shown as relayed. The node's status and Settings said "mesh direct" while every peer went through the relay, because newer agents write via instead of an endpoint for a relayed peer. A warning from the agent also stayed up for hours; it now clears once the relay has reconnected, or after ten quiet minutes.
A WSL root no longer reads "no git" after start-up. The start-up check ran git rev-parse under a 15 s limit while WSL woke up, and a timeout counted as "not a repository". Only git's own answer changes the flag now; a timeout keeps what was known.

0.34.19

Approve from the node's chat. When the specialist you are talking to stops for a permission, the approval prompt opens right there under the conversation: 1 allows, 2 denies, Enter allows the highlighted request, ↑↓ move between several, Esc puts it away for /approve n later. Letters do nothing while it is open, so a message you start typing ("do it") cannot answer for you; once you have typed something the prompt steps aside.
The transcript reads like a conversation. Your lines wear ›, a reply is signed with the specialist's name (● Hannah), what the agent is doing sits under it as ⋯ Read README.md, an approval is ⚠, confirmations ✔ and errors ✖; long lines hang under their mark and a blank line separates turns. The prompt says who you are talking to (Test · Hannah ›), the specialist picker lists one choice per line, and "Hannah is replying…" names her, not the root.

0.34.18

A chat from the node really does go to the specialist you picked. The node sent the specialist as the turn's team, which the host reads as "facilitate this team" and answered with a fresh Facilitator agent — the REPL said "talking to hannah" while Hannah's runtime was never started. facilitator.send now takes specialist, and a chat over the Control API is bound to the specialist it names or the one its conversation already has. Anything else is refused with the specialists there are; the host never picks one and never starts an agent of its own.
The node always asks who should answer, even when one specialist is defined: /chat offers the numbered list and waits. --specialist <id> skips the question; mojoup-node chat off a terminal needs it and otherwise prints the choices.
A desktop attached to a node root is a contributor again, not an owner. 0.34.13 widened a no-project peer token to owner so a specialist could be saved on a node root; 0.34.14 fixed that properly (a team save needs teams:write, and a team setting from a contributor lands in the root's repo layer). With both, a role's runtime set from the wizard went to the global layer instead of .mojoup/settings.json. The escalation is gone.

0.34.17

A chat reply no longer splits in two after the host restarts. A conversation that kept its still-running session after a restart was not re-entered in the host's session map, so the first chunk of the next reply fell to team narration, which opened a second assistant message that then took the rest. The reuse path now remembers the binding, and a chunk for a bound chat session re-binds from the conversation before it can be narrated.
The node's chat never starts an agent of its own. /chat on a root goes to a specialist: the only one defined answers; with several, the REPL asks who should answer with a numbered list; with none, it says so and sends nothing. mojoup-node chat off a terminal takes --specialist <id> or the only one, and otherwise lists them. Before, a chat without a specialist went to the root's default chat agent, which spawned one of its own.
teams.list on the Control API says each team's kind and its first member's role, which is what the node's picker offers.

0.34.16

A chat reply carries who wrote it. Every assistant message in a chat is signed by the session that served it — its name, character and colour — when the host creates it, and the chat shows that before anything it works out itself. A desktop attached to a root on a node showed "Agent" with an initial for a specialist's replies because it had never learnt the conversation's binding; it now shows the specialist's name and character, as a local root does. Both the desktop and the node need this version, since the host signs the message.

0.34.15

An approval shows up in the node's chat, and is answered there. When the agent you are talking to in mojoup-node chat (or the REPL's /chat) stops for a permission, the request appears in the conversation with its number and the commands that answer it — /approve 1 allows · /deny 1 refuses — and the status line says so. It used to point you at the dashboard. Off a terminal, the plain chat says where to answer it. The node needs this version.

0.34.14

mojoup-node chat --specialist <id> talks to that specialist on the root instead of the root's default chat agent, which is what answered before however the specialist was named; in the REPL, /chat [root] --specialist <id> does the same. The node needs this version.
A specialist is named once and starts as a generalist. The wizard's first field names the specialist and the one agent it consists of; the roster step shows that name instead of asking for it again. The agent's role defaults to Generalist, with its instructions, where the roles offer one; any other role can still be picked.
Creating a team or specialist on a node root works. The save was refused for a desktop attached over the mesh because it needs the settings scope a peer never has; team definitions kept in the repository, and the team-related settings the wizard writes, now need only the teams scope a contributor or owner holds. When a save is refused the wizard says so and why instead of finishing quietly, and refused writes name what was refused in the audit.
The node's manifest holds still. Probes that could not answer no longer flip values, and detail changes are published at most every five minutes; the log names any key that moved.
Status writes on Windows retry while another program holds the file open.

0.34.13

Specialists and teams can be saved on a node root. A desktop attached to its own root on a node assigned to it — no enterprise project in the token — now acts as that root's owner: hosts:attach grants settings:write, git:write and memory:write beside teams:write, so saving a specialist, a layout or a key no longer fails with "may not save-team-config". Inside a project the owner role gets the same; contributors and viewers do not. Never ui:*. The mapping runs on the node, so the node needs this version too.
The node dashboard's panels scroll. In /logs, /doctor and help, ↑ ↓ move a line, PgUp PgDn a page, Home and End jump to the first line and back to the tail; the title says where you are. The log used to show its last screenful and nothing else.

0.34.12

A root on a node no longer reads as "no git". Commands never run on a node from the desktop, so the project store's git probe answered false for every node root. The git fact and the origin URL now come from the node's own read-only answers: its state answer for the folder says whether a .git is inside, and .git/config is read for the remote. Applied when a node root is added, when it is opened, and on the start-up validation; a node that cannot be asked keeps the facts it had.

0.34.11

One agent node, an extension of the workbench with distributed reach. Two node designs had grown side by side; the app now has one: the workbench itself runs on the node, and this desktop attaches to its host over the mesh with a token the organisation mints. The board, Team Work, the Git view and approvals of a root on a node are views in this app; the node keeps working when the desktop closes; several desktops can attach to one root; the console and phone reach it too.
The root wizard's node path works end to end. Readiness asks the node what it has (git, agent CLIs, home folder, roots) instead of running commands on it — the "Git not found on node" block is gone; the Source step browses the node's home folder read-only and picks a repository or a root it already serves; Prepare asks the node to serve a folder, attaches and opens the board.
A root on a node reads like any other root, with one "on <node>" tag; local roots no longer carry a "Local" chip. A node that goes offline shows one status line on the root and reattaches quietly when it is back; what a node root cannot do yet (external editors, native pickers, terminal commands on the node) says so in a sentence.

0.34.10

Git on a node acts as the person the work is for. Roots that belong to an organisation project get a git credential helper answered by the running node: it asks the platform for a one-hour credential for the person who started the session (through a desktop over the mesh, or the console), only for the project's own remotes, cached in memory and never on disk. Unattended work gets the organisation's credential when the connection allows it, else a clear refusal.

0.34.9

Background start works from the single executable. mojoup-node start, run --daemon and the service exited at once on 0.34.8 because the detached launch inherited the variable that makes the executable act as plain Node for its hosts; self-launches now clear it and the executable only honours it for a real script file. stop also terminates every host the node spawned.
Setup keeps your choice. Enter alone picks the highlighted item in the change menu, which now returns after each step until Done; the banner prints once; "Run it here" and run show a spinner instead of log lines until the REPL takes over.
Home folder and repositories. A Home folder step in setup (node.home, /config set node.home, setup --home), clones default into it, and the manifest reports it to the organisation. The Repositories step lists the node's roots with add and remove, as do /roots, /roots add <path> and /roots remove <n> in the REPL.
One mesh word everywhere — direct, relayed, joining, pending approval, off, error — read from the agent's own status, so the status bar no longer says "off" while the mesh is up. The node remembers the control port it chose, so its services stay stable across restarts.

0.34.8

The node's terminal is a REPL, not a log dump. mojoup-node on a running node, run in the foreground and chat all hand the terminal to a Claude Code-style session: a prompt with a status bar, a transcript pane, and / opening a filtered command menu — /status, /logs, /approvals with allow and deny, /chat <root> and /end, /hosts, /agents, /doctor, /service …, /secrets …, /update, /help, /exit. Ctrl-C twice or Ctrl-D leaves; leaving a foreground node asks whether to stop it or hand it to the service.
The banner shows the real mark, generated from the app icon: the white cube on the amber circle in block characters, in the icon's own colours.
The team wizard and builder say where a team runs. One line above the roster names the node when the open root lives on one.
Settings → Organisation reads a 401 on the project routes as a plain sentence, not as a revoked workbench: an older platform only takes a person's token there.

0.34.7

The agent node is a product, not a zip. mojoup-node is a single signed executable installed with one command (irm …/node.ps1 | iex, curl -fsSL …/node.sh | sh, or from the C:\MojoUpBuilds\node folder), on PATH, updating itself with mojoup-node update. Run with nothing set up it opens a setup wizard (sign-in with a clickable device code, name, tags, roles, repositories, run at startup); once running it is a live dashboard with pending approvals you answer from the keyboard, plus doctor, logs -f and chat. It opens with the Mojo Up mark and the "AI Workbench Node" title.
A daemon the CLI turns on and off. mojoup-node service install | start | stop | restart | status as a Scheduled Task on Windows, a systemd unit on Linux or a launchd agent on macOS, or run --daemon where there is no service manager; a Windows tray icon (--tray) shows the state with start, stop, dashboard and logs. Secrets move into DPAPI, the Keychain or secret-tool ahead of a key file (secrets migrate).
The desktop opens a node's roots as views in the app. "Open" on the Nodes card (and the root wizard's "AI Workbench node" choice) attaches the desktop to the node's host over the mesh with a peer token: the board, Team Work and approvals of a node's roots, several desktops at once, with the person on every audit line and the assignment's quota enforced.
Headless agent nodes land on main: the node supervisor, the ssh: target, per-session agent credentials, the managed-policy pin and the hash-chained audit trail, and the bundled mesh agent rebuilt from the platform (6d82fdf, which knows the node kind and the HTTPS relay).
Settings → Organisation lists the enterprise projects you belong to. A Projects group beside Nodes shows each project with your role, its roots and which node holds the board of record, its members and the compute assigned to it, and marks the projects a root on this desktop is part of. Fetched from GET /projects/v1 with the desktop's device token, refreshed every five minutes and on Refresh; an organisation without enterprise projects reads as one plain sentence, not an error.
Grok Build is in the Updates pane. It installs itself from x.ai's script, so it had no npm package to check and was left off the pane. Its own grok update --check now answers the version check and Update runs grok update; the row says the number came from its own updater.
A runtime switched off under Settings → Runtimes no longer gets an update row.

0.34.6

Skills are checked against the Agent Skills specification. Every skill under .claude/skills, .github/skills and .agents/skills is validated on the rules at agentskills.io (name shape and folder match, description, compatibility and metadata limits, the 500-line body advice); a skill that departs from them shows one "not to spec" chip on its Customisations row with the reasons, and a skill published through the organisation's catalogue is flagged in the sync result when it fails (still installed). allowed-tools is read, never treated as permission.
Attributions credit the Agent Skills specification.
The console's "Take control" reaches the workbench over the mesh. POST /mirror/input on the mesh endpoint is served like the LAN listener's: signed by the platform with ui:control, under the "Allow clicking and typing" consent, and audited on refusal. It answered 404 before.
The title-bar badge says "controlled" when the console takes control. The console watches with view rights and signs each click and keystroke with control rights, so the badge stayed on "watched"; a viewer whose signed input arrives now counts as driving.

0.34.5

Setup works on a Linux desktop. The first-run check's Install for the credential manager now installs Git Credential Manager (the newest .deb for your architecture, then configure, with credentials kept in the desktop keyring) instead of running a link as a command. Install the CLI for Dev Containers puts it in ~/.local rather than npm's root-owned global folder, where it failed with a permission error, and the app finds it there even when ~/.local/bin is not on its PATH.

0.34.4

Grok Build is a runtime. xAI's coding CLI (grok) speaks ACP natively, so a team member can run on it: grok agent stdio, its own browser sign-in or XAI_API_KEY, a terminal launch profile, and detection under Settings → Runtimes with the one-line installer.
xAI (Grok) and Amazon Bedrock as model providers. Store a key under Settings → Models and any BYOK member, the facilitator or the semantic memory pass can use them. Bedrock is reached through its OpenAI-compatible endpoint with an Amazon Bedrock API key — bedrock.region picks the region, bedrock.endpoint chooses runtime (recommended, type the model id) or mantle (lists models) — so no AWS signing is involved.
Claude Code on Bedrock. A Claude Code member whose provider is Bedrock runs natively (CLAUDE_CODE_USE_BEDROCK=1) with the region and key the workbench holds; a stray Anthropic key in the environment is removed so it cannot win.
WireGuard is credited. The Attributions page and the README acknowledge wireguard-go, which the mesh agent is built on; the rest of the app now says "mesh tunnel" rather than naming it.

0.34.3

The Git layer is production-hardened, end to end. The repository policy's protected branches are enforced on every merge, push, sync, landing and delete; every git write is on the audit log with its real outcome and the window that asked for it; and two injection paths (the commit graph's branch filter, the signing scripts) are closed.
Nothing loses work silently any more. Worktrees are repo-namespaced (two projects in one folder can no longer hand an agent the wrong tree), the housekeeping commit can no longer sweep your staged files or your policy edits, the landing sweep leaves a conflict you are resolving alone, a deleted branch offers one-click restore, and cleanup only deletes branches whose work is merged or integrated.
The Git view grew the missing tools. Stash and pop, a rebase-or-merge choice when your branch and its remote diverge, banners for a half-done merge or rebase, cancellable clones, two-step confirms on destructive actions, and honest "unknown" instead of "clean" or "no changes" when git could not answer.
Signing setup is safer. SSH signing refuses git older than 2.34 (which it would break), a test signature runs right after setup on every platform, and the allowed-signers file is written where git actually reads it.
Faster. The branch model is one git call instead of hundreds on branch-heavy repositories, and status probes no longer take the index lock under your commits.

0.34.2

Workbenches enrolled before the mesh existed join it. The organisation's discovery document is fetched again at start-up, every six hours and after a "not found" from the platform, so what the platform adds or moves later — the mesh, its signing keys, the relay's address — takes effect without signing out. The copy on disk is kept when the platform cannot be reached.

0.34.1

Reach your organisation from a network that lets HTTPS out only through a proxy. Sign-in, the fleet and remote control now use the system's proxy settings (PAC and WPAD included, with Windows proxy sign-in and the Windows certificate store), and the mesh agent is started with the same proxy, so its HTTPS relay works where the tunnel's UDP is blocked. It is checked again every minute, so moving networks is picked up.
platform.mesh.proxy overrides the proxy: direct, or a proxy URL.
Settings → Organisation says when traffic goes over HTTPS through the platform's relay, and through which proxy.

0.34.0

On your organisation's mesh. Once signed in, the app runs the bundled aioe-mesh agent and joins the organisation's private mesh network, so the console reaches this workbench directly ("via mesh") and falls back to the relay when it cannot. Every request that arrives that way is signed by the platform and checked before anything runs; anything unsigned, expired or meant for another device is refused and written to the audit log.
Settings → Organisation shows the mesh: the overlay address, whether traffic is direct or relayed, each peer with its last handshake and endpoint, and a switch to leave the mesh.
The console's remote workbench shows more. Agent replies in Chat, Research and Team Work (sessions.transcript), messages sent into real Team Work and Chat conversations (facilitator.send), research that files its report as the app does (research.start), and the Plans waves, critical path and acceptance (plans.get).
The screen mirror stops capturing when its viewer leaves, even when the window has nothing new to send.

0.33.1

Finding your organisation from your email works with the record as published. A discovery TXT record that holds just the API host (aioe.mojoup.com.au) or an https URL is accepted as well as the platform's v=aioe1; url=… form.
The ROCm llama.cpp build installs on Windows. The final move of the unpacked build into place used to fail with EPERM while the antivirus or indexer still held one of its DLLs; it is now retried and, if Windows still refuses, copied into place.

0.33.0

Sign in to your organisation. Settings → Governance → Organisation: enter your work email and the app finds your organisation's platform (the AI Enterprise Operating Environment), opens the console with a sign-in code filled in, and from then on the workbench is listed in the console's fleet as online with its workspaces, sends its events, usage and audit there, pulls the organisation's policy into .mojoup/policy.json ("Managed by <your organisation>" on the policy card) and its template catalogue, and answers the console's remote control through the desktop's gateway, each request going to the workspace it names. One sign-in per desktop serves every root, WSL distro and dev container; Sign out forgets it. A platform URL from your administrator works where the email domain publishes no record.

0.32.9

The VS Code extension is gone. The workbench has been a desktop app since 0.14; the extension that stayed on as an optional bridge — the activity-bar views, status bar, editor panels, chat participant and Copilot Chat tools — is removed with its manifest, packaging and build skill. Nothing the desktop app does changes: the core was already runtime-neutral, and every setting is still declared in one place (shared/settings/declarations.json, which the schema is generated from). Opening files in VS Code or any other editor from the app works as before.

0.32.8

The rings' project scope is the whole project. "This machine" showed three targets and said nothing. Switching the rings to This project now has the desktop ask every root's host for its snapshot — customisations, the areas of its code, its roadmap, its plans and the shape of its memory — and draws them all on one map, each root's nodes labelled and kept apart, the links staying within their root. The Find panel says which roots are on the map and which are not (a host not running is named, never woken).

0.32.7

The Memory view says what it shows: This root, Rings, Every root; the rings' Find panel switches between This root and This machine, and the machine view keeps this root's rings and adds the machine's targets and projects around them instead of replacing them.
Specialist runs have their own history. A one-shot run a routine, a review, a roadmap draft or a merge asked a specialist for is filed under Specialists in History, named for the specialist, and kept out of Chat's list and its history.

0.32.6

The ARMS rings link up, in the order the work flows. Roadmap, Architecture, Plans, then Applications, Routines, Memory and Skills. The links stay faint until you read a node, then light up with it, and Details lists them as a way in.
The Projects view has a hero, not a diagram. Artwork in the app's own language, a ring of roots lit down to three target bands in the wizard's target colours, agents drifting along the lines; the words are one line beside it and the dialog it opens.
Wizards ask only for what is missing. The Tools step no longer offers to reinstall an adapter for a runtime that is already installed, and the Where step's requirements heading names the distro ("What Ubuntu-24.04 needs") instead of the kind.

This round: the local model as the machine's service and several models at once, one per agent; Documents; Team Work sessions scoped to their own intent and questions; the Projects view's picture of the model; settings and memory aligned to it; three more rings on the ARMS map. Parts of it were already in the tree when 0.32.3 and 0.32.4 were built; this build has all of it.

The local model is the machine's service. The desktop app runs it in a host of its own on its OS — Windows on a Windows desktop, where the GPU is — for every root, WSL distro and dev container, and with no project open at all. Settings → Local models and the setup wizard's Local model step manage that one service from any window, with a "Runs on Windows" badge; the "open a Windows project" detour is gone. A new Service card switches it on and off (saying what in the root stops working — the DLP classifier, memory enrichment, the merge-conflict resolver) and whether the model is served as soon as the app starts. A model library a root downloaded before is adopted, not downloaded again. The runner's own progress no longer floats over the wizard that already shows it, and the floating progress card the other jobs use is opaque now. The Updates pane's llama.cpp row comes from the service too, so a newer build shows there as well as on the Engine tab, and Check for updates asks the service.
Several local models at once, one per agent. The bundled runner now runs one llama-server per model, each on its own port. Run a second model from the hub beside the first (the machine's memory is checked before a third joins), give a team member provider "Mojo Up local model" and any downloaded model, and its requests go to that model's server — started on demand the first time a member asks for it, on the machine's service when the root is served by it. The selected model stays what memory and the merge resolver use; Stop on a model row stops that one, Stop all stops them all; the Inference pane and the tray list every model up. A switch on the Service card, "Start a model when an agent asks for it", is on by default; off, such a request fails with a message rather than starting the model or being answered by another one.
Documents. The Docs view is called Documents, and its preview renders mermaid diagrams, raw HTML and relative images like the editor's. What a repository counts as documentation is a setting now (Settings → Projects & Editors → Documents): the documentation folders, whether a new document is OKF or plain Markdown, and a templates folder of the repository's own — every Markdown file there with template: in its front matter is offered under "This repository" in New document, listed under Templates in the tree so it is edited in place, and New template writes a scaffold there.
A Team Work session sees only its own intent and questions. A new session used to open with the team's last intent — a plan from an earlier run — and its cards, and a question an agent asked appeared three times: in the conversation, in the Agents rail with the same choices, and as a toast over the card it named. The intent and every question are scoped to the conversation they belong to; the rail says an agent is waiting and takes you to the conversation; the toast stays quiet while that conversation is on screen.
The Projects view draws the model. A picture of the project this window shows — its roots inside the project box, each hanging from the target it lives on, agents travelling down the lines — and, pressed, the explanation in words: what a project shares (a settings layer and project-scope teams), what stays with each root (its board, plans, memory, sessions), and the settings order that follows. The project switcher's Add root sits under each project's heading and the wizard's title names the project the root goes to.
Settings and memory say the same thing. The scope chip on a settings row names the four layers in the order they win — Global, Machine (this computer, a WSL distro or a dev container), Project, Repository — with a line each on who sees the value; the setup page is called Setup, so nothing else is named "This machine". The Memory view and the Knowledge sources card say what each scope holds and that every root builds its own graph.
Memory follows the model. Your notes folders are the machine's, so they are indexed once per machine and shared by every root (an index under the host's machine storage; the first root to need it writes, the others read); a folder named relative to a repository stays that repository's. And a memory question can be put to a whole project: the new Project scope in the Memory view's ask box has the desktop ask every root's host and line the answers up, naming a root whose host is not running rather than waking it.
Three more rings on the ARMS map. Roadmap (rows grouped as the map colours them), Plans (every plan on every board, grouped by where it is in the loop) and Architecture (the map's areas, grouped by layer) join Applications, Routines, Memory and Skills; each node opens its own view.

0.32.4

A specialist drafts the roadmap. The roadmap wizard and the new-item dialog offer only specialists as the drafter — starting on the routines' default when it is one — and say where to define one when none exists; the default chat agent is no longer an option there. In the item dialog, Status and Phase now sit above the areas of the code.

0.32.3

A roadmap you can build, not only read. The Roadmap view's new wizard takes the product vision in your words, has a specialist (or the default chat agent) ask up to five shaping questions, proposes the items over the Architecture map's areas with an opening paragraph, lets you edit every row, and writes docs/roadmap/README.md. A repository without a roadmap starts here; Research and Team Work carry a card for it.
Items drafted from a feature. Adding an item reads top-down now — what, where and when, proof — and "Draft with <specialist>" turns a feature description into the title, areas, phase and description.
Hand an item to a team. Plan with a team on any row opens Team Work with the item as the brief to shape, plan and deliver, marks the row in progress, and asks the team to put the id in its commit subjects; a row whose id the log then mentions shows "in the log" with a one-press Mark done.

0.32.2

CI is green again. Every macOS and Windows run since 21 September failed on one thing: the Routines page's template gallery (RoutineTemplates.tsx) and its catalogue (routineTemplates.ts) differed only in case, which those platforms treat as one file. The catalogue is routineTemplateCatalog.ts now, a test fails the Linux run if two tracked names ever differ only in case again, and the file-watcher tests give macOS's FSEvents stream a moment to come up before the first write.
The Update button answers. Pressing Update on a runtime in the Updates pane now shows every step on the row — checking, waiting for you to confirm the command in the dialog, running, and "Not started" with the reason if the confirmation was dismissed or could not be shown — and logs each one. Before, a lost confirmation looked like nothing had happened.
Your own redaction rules. Under Workspace policy, Custom redaction rules takes named regular expressions — customer ids, internal hostnames, ticket keys, project codenames — with a Try it box that shows what a sample turns into and an Examples list to start from. They apply after the secrets and personal-data patterns to anything bound for a hosted model, on the proxy and on the prompt path, never to a local model (llm.redactPatterns; a repository may commit its rules). The policy chip counts them. A new test sends a token, an email, a card number and a customer id through the proxy to a fake upstream and checks that none of them arrive on a hosted route and all of them do on a local one.
Roadmap items, managed in the app. Add item and a pencil on every row open an editor: the id (next in its series), the title, the areas of the code as a pick-list from the Architecture map plus any folder you type, the phase, the status and the evidence, which a done row must have. Saving rewrites that one line of docs/roadmap/README.md and leaves the rest of the file as written; a repository without a roadmap gets one started.
Docs: a tree, kinds in colour, and agent instructions understood. The document list is a folder tree with a colour per kind; agent instruction files (AGENTS.md, CLAUDE.md, GEMINI.md, Copilot's instructions, skills, prompts, agent definitions under .github, .claude and .agents) are their own kind, say which CLIs read them, and are no longer told they lack an H1 — a skill without name and description in its front matter is, because no CLI would list it.
Docs: Print, Save as PDF, Save as OKF. Print and Save as PDF render only the document, on white; Save as OKF writes a structured copy beside a Markdown file with the title in the front matter and each heading typed by its words, and says which headings it could not place.

0.32.1

A team's office exists while the team runs. The office's team control used to list every configured team, running or not, so starting one team put every other team's empty room beside it. Now a team has an office only while it has agents in it; when its last agent stops the office goes, and a window looking at it returns to the solo office. Idle teams live on the Teams page, where they are defined.

0.32.0

A Roadmap, over the map. A new Roadmap view under Project reads the repository's own docs/roadmap/README.md — the table npm run docs:roadmap checks — and shows what has landed, what is in progress, what is planned and what was set aside: four counts you can press to filter, the rows by series (Security, Desktop, Onboarding…), a search, and each row's evidence on press, with "Done — unverified" on a done row whose evidence names no commit in this checkout. Every row names an area of the code, so the same rows now draw on the Architecture map: tick roadmap and each area card carries a slim bar — landed, in progress, planned, set aside — sized by how many rows name it, the legend replaces the counts, and the panel lists the rows on the selected area. An area chip in the Roadmap opens the map on that area with the overlay on. A repository without a roadmap is told the format and offered a start.
Routines have a default runner. Runs by default, at the top of the Routines card, names the specialist every prompt or review routine goes to when the routine itself names nobody (routines.defaultSpecialist); the routine dialog's Default option and each row's badge say who that is. review.specialist still names the review's own writer when set.
Files open in the workbench. A doc, a customisation, the workspace policy, a pipeline definition — anything the workbench opens now lands in the built-in editor on the right, at the line when one is known, instead of being handed to an external editor that under WSL often had nothing to open with. Open files in (Settings → Projects & Editors → Editor) switches back to the external editor; the editor's own toolbar still offers it for any file, and files outside the repository always go there. The editor's "Open in external editor" button now sends the right path for a file from a worktree or branch. The Docs view's "Open in VS Code" is "Open in editor".
One key list per provider. Inference gateways shows each provider as a card: its default key, every named key under it (name, endpoint, stored or not, Replace, Remove) and Add key on the provider itself — the named keys were there before, behind one button under the whole list, and nobody found them. A named key can now also be chosen for the Chat agent's backend (Chat key, shown once the provider has named keys; facilitator.chatCredential), and the gateway sidecar honours a member's named key instead of quietly billing the provider's default: the route carries the key's name, never the key, and a name the sidecar does not hold is refused by name.
Every agent is briefed on the repository's customisations. At start, each agent gets one line per skill, prompt, agent, instruction file and MCP server its own CLI would not find — Claude Code hears about .github/skills and .github/prompts, Codex about .claude/commands and .github/agents — with the path to read when it uses one, so a customisation written for one CLI works from every runtime without its file in the context (customisations.briefAgents, Settings → Customisations).
PII redaction, and the prompt path covered. Beside the secrets redaction, email addresses, phone numbers, payment card numbers (Luhn- checked), IBANs, tax file and social security numbers are redacted from anything bound for a hosted provider (llm.redactPii, on by default). The pattern layer now also runs on the prompt path that Copilot CLI, Claude Code, Codex and Gemini sign-in use — before, without the optional local classifier, those prompts left unredacted. The policy card says what is on in plain words ("secrets + PII redacted", "classifier off") with switches for both, and local models are never redacted.
Docs list. The Obsidian mirror mark on a document is a quiet icon at the end of its row, not a "vault" badge on almost every line.

0.31.0

Memory, rebuilt around the map. The Memory page is no longer an engine console. The map is the control: one dark stage with everything floating over it — how to look at it (Space, Flat, Rings, Grid), Find (/), a Topics panel that filters, a details panel that says what the selected item is in a sentence with its first source lines and what it connects to, how much to draw (Essentials, Balanced, Everything), orbit, fit and zoom — and full screen is the same stage, larger. Ask your memory replaces "ask the graph": ask a question or trace a connection between two things, get the answer as cards that light up on the map, or hand the question to an agent in Chat. Where memory comes from lists code, documents, note folders, the Obsidian vault and your Inbox with a freshness chip; the maintenance buttons moved behind one Upkeep fold. Plain words throughout: items, topics, cornerstones; certain, likely, unsure.
Workspace (ARMS) gets floating panels. Search left the hub: a Find panel on the left (/ or Ctrl+F, results by tier, keyboard navigation, the index doubles as the legend) and a docked Details panel on the right replace the centre box and the modal, and the rings re-centre between them.
Office layouts. Layout → Templates opens seven ready-made offices — Solo studio, Small team, Library, Classic, Open plan, Ops room, Squad pods — each with a drawn thumbnail and its desks and seats, the smallest that fits the running team preselected, and a warning with Export when it would replace an office you customised. Characters keep their seats, and nobody is left standing in the furniture after a switch.
The plan graph, properly drawn. Tasks sit in dependency waves as bands toned by state, cards read across the room (running pulses, blocked is unmistakable, concerns and gaps are pills), a header carries counts, a progress bar and the edge legend, a long chain wraps to fill the canvas, and selecting a task lights its chain and opens its details.
Routines say who runs them, and clean up. The daily review is written by the specialist you choose — on the routine, or with Written by beside Review now (review.specialist) — instead of a randomly named chat agent, and an agent started only for it is stopped as soon as it has answered. "Default chat agent" now says what it resolves to and links to where that is set (Settings → Models → Chat & Team Work). The Architecture map's describe job is a routine template (Architecture map, weekly): it goes to the scribe, never files the task twice, never takes over the window, and asks for an update once the file exists. Docs freshness suggests your scribe.
Idle agents stop. An agent that a routine, the daily review or a task filed for a specialist started is stopped after ten idle minutes (agents.idleStop, agents.idleStopMinutes, under Settings → Agents → Chat agents) — never a team member, never one waiting for your approval, and one you start talking to is yours to keep.

0.30.0

Pipelines, in full. The Pipelines view (now under Automation) reads every GitHub or Azure DevOps remote of the root, not only origin. Open a run to see each job's steps — a failed job opens on the step that broke — and read its log in the app: timestamps and colour codes stripped, errors in red, and an Errors filter that keeps only the failing lines and what led up to them. A run held at a GitHub deployment environment or an Azure stage approval shows as waiting, with who may approve, and you can approve or reject it from a Review dialog; you are told once when a run starts waiting for you. Approvals are made only by a person in the app — never an agent or a remote client — and every start, re-run, cancel and approval is on the audit log. Azure DevOps needs the Build (read & execute) and, to approve, Pipeline Resources (use) scopes on the Personal Access Token.
Agents can use CI. pipelines_list, pipelines_run_get and pipelines_log let an agent see whether CI passed and read why it failed; pipelines_run, pipelines_rerun and pipelines_cancel follow the new pipelines.agentRuns setting — by default you are asked each time, and no answer is a no. A repository cannot loosen it. The Control API gains pipelines.list, .jobs, .log and .act.
The live monitor, redesigned. Rolling two-minute lines for CPU, GPU busy, memory, GPU memory and the model's tokens per second, a model card with the KV cache and the queue, GPU devices with dedicated and shared memory, and a compact form for the floating and always-on-top windows. A Machine | Agents switch shows the agents working in every open workspace — local, WSL and dev containers — with what they are doing and for how long.
Answer agents where you see them. In the monitor's Agents view and the right-hand Agents pane, an agent's pending approvals show their own options (allow once, allow always, reject) and short questions get answer buttons; an approval for another workspace is sent to that workspace. Each agent has a button that opens Mission Control on it, switching workspace first when it is elsewhere. The chosen option now reaches the agent exactly — "allow always" used to be sent as the first option.
One look for every map. Git's branch map, the team map and a plan's graph now share Architecture's design: tinted bands, compact cards, arrowed lines, the zoom stack and a minimap that appears once there is enough to need one and no longer turns grey in the light theme.

0.29.0

Pull requests in the Git view, for GitHub and Azure DevOps. Git → Pull requests lists the pull requests on the root's origin, the ones waiting for your review first, then yours, all open and closed, with search. Opening one shows its description, each reviewer's verdict, the checks (on Azure DevOps, the branch policies, with the required ones marked), the files with their diffs and the conversation. From there: Approve, Request changes, Comment, Merge with the method the repository allows and the branch deleted afterwards, Close, Reopen, and Ready for a draft. Azure DevOps keeps its own words: Wait for author, Complete, Abandon, Reactivate, Publish. Merge and Close ask once more before they are sent, and a merge names the commit you were looking at, so a push that lands in between is refused rather than merged unseen. A banner says whether it can merge and, when it cannot, what stands in the way; a failing optional check or an objection warns without blocking. Azure DevOps sends no diffs, and GitHub leaves out the large ones, so those are read from the local repository after fetching the two branches.
Every pull request action is audited. Approvals, comments and merges are made under your own account through the control layer, so the audit log names who did what to which pull request; a comment is summarised there, not copied. The Control API has pullRequests.list, .get and .act (git:write), validated by the same schema as the UI.
Review with an agent. A pull request can be handed to Chat for a first read: the prompt names the diff to read and forbids checking out, committing or pushing. The agent reports; the vote stays yours.
Open pull request uses the API when you are signed in. It is the only way that works on Azure DevOps, where the button used to open a web page, and on GitHub it no longer needs gh. With no title given, the branch's newest commit names it. gh, then the provider's page, remain the fallbacks.
A setup guide for Git. Six steps worked out from what the app already knows: git on the root's target, the name on your commits, a credential helper, a remote, an account on the remote's host, and how finished work lands. Identity is set in place; a missing remote opens the connect-remote wizard; the account step signs you in without leaving the view. It opens by itself only while git or an identity is missing, and sits behind a Setup guide button otherwise.
"Push after landing" has a switch. The setting existed with no way to reach it outside a settings file. It is in the guide's last step and under Settings → Branches & merging.
The Git view is three tabs. Overview (the branch map and commits), Pull requests (badged with how many wait on you) and Branches (merge queue, worktrees, branches), instead of one long scroll.
A routine says who runs it. A prompt routine can name a specialist, who answers in Chat, or a team, which takes it as Team Work; an ops review can name the team whose operations manager does it. Every routine row shows who runs it, and flags a runner that has since been deleted rather than changing it quietly. "Start a team" no longer offers specialists or the built-in team.
The Memory setup guide, rebuilt, without git hooks. Step tiles with a progress bar, and automation as two cards: the watcher, or by hand. The guide no longer offers to install git hooks; a repository that still has them from an earlier setup is told, with one button to remove them. The Memory and Git guides are the same component.

0.28.1

Git has the look the rest of the app has. A proper header; five numbers you can read from across the room — what is checked out and whether it is clean, how far it is ahead of the default branch, what is waiting to land, how many branches and worktrees, and whether there is a remote; and the branch map, commits, merge queue, worktrees and branches each in a titled card. The map's legend sits with the map it explains instead of in the header.
Canvases follow the app's theme, not the operating system's. The branch map, the plan diagram and the agent cards used the system's colour mode, so with the app set to Light on a dark desktop they were black slabs in a light window. They follow the app's own switch now. The branch map also stops shrinking a handful of branches to fit the whole canvas.
Architecture's layers are seven things, not one grey stack. Each layer is a band in its own tone, the view opens with the same header as the others, and its size is four counts — layers, areas, files, links — rather than a sentence.
Updates, Usage and Inference match. The dock panes share one header — a small icon well in the pane's tone — and one style of section label, and say "nothing yet" the way the views do.

0.28.0

Local models is a hub. Settings → Local models has four tabs. On device lists what the runner can serve, runs and stops a model, and holds each model's settings. Discover searches Hugging Face, marks every quantisation in a repository for whether it fits this machine, and suggests one: the largest that fits comfortably, on the GPU if any does, passing over full precision while a quantised file fits. Engine is the compute backend and the llama.cpp build behind it. System is the hardware, live.
Compute backends: CPU, Vulkan, ROCm and CUDA. The ROCm builds (Windows and Linux) and the CUDA builds (Windows, with the CUDA runtime as a second archive) are pinned with their hashes beside CPU and Vulkan. Automatic stays on Vulkan, which needs nothing but the driver; the vendor's own stack is suggested for its hardware and is one Apply away. A build that is not on disk is asked about before it downloads: a running model restarts on it, and otherwise the next start uses it.
llama.cpp can be updated without waiting for the app. The pinned build is still what a first set-up installs. Upstream publishes several builds a day, and a new model architecture usually needs one of them, so Engine and the Updates pane now offer the newest. It is downloaded from the official ggml-org release only, every archive is verified against the SHA-256 GitHub publishes for it, and Use the pinned build goes back. localRunner.allowBuildUpdates turns the check off.
Load settings and run settings, per model. Load settings are how the model gets into memory: context length, KV cache type, GPU layers, parallel slots, flash attention, mmap / mlock, vision, reasoning and its budget, and under Advanced the batch sizes, tensor parallelism, MoE layers kept on the CPU, fit-to-memory and its margin, checkpoints, cache RAM, a chat template, speculative decoding and extra arguments. Run settings are the sampling the server starts with — temperature, top-p, top-k, min-p, repetition and presence penalties, max tokens, with presets — which is how a model card's recommended values reach agents whose CLI never sends any. Every flag was checked against the pinned llama-server. Save and reload model applies them now.
A live monitor, in a window that stays on top. CPU, memory, the disk the models are on and GPU memory — dedicated and shared, which is the number that matters on an APU — read every two seconds while something is showing them and not at all otherwise. In the desktop app it opens as a small always-on-top window of its own, so it is still there when you go back to your editor; there is only ever one, and it is a page of its own rather than the whole app behind a panel. The title bar has a button for it, View → Live Monitor and Ctrl+Shift+M toggle it, and it is in the command palette. Inside the app it can also float over the views, and remembers where you put it.
Start and stop the local model from the tray. The tray names the model that is serving and what it is running on. The Control API has localModel.start and localModel.stop (agents:write) for the same.
A finished plan offers the way back to main. A plan now remembers the branch it was made on and shows it. Once the plan is complete, Plans says how far that branch is ahead of main, with Merge into main and Open pull request as two buttons — including when the branch is not the one checked out, in which case merging it does not move you off the branch you are on. The card also says when there is nothing left to merge, when the branch is gone, and when uncommitted changes hold a merge back (a pull request can still go ahead). Getting Started has a new "Getting your work back to main".
Merge, Open PR and Push for every branch in the Git view. The Branches table stopped at Open, Switch and Delete, and the branch you were on was the row that could do least. Every branch now says how far it is ahead of the default branch and offers the three, each with the reason when it is off: nothing to merge, uncommitted changes, no remote, already pushed.
One branch pill, not five controls. The top of Chat, Research and Team Work carried a branch chip, a Merge button, a status line and — above the composer — a card asking a question with two more buttons in it. It is one pill now: the branch, with a count when commits are waiting and an amber dot when the checkout has uncommitted changes. Pressed, it opens a small popover that says where the branch stands in a sentence, offers Merge into main and Open pull request, and has a field for a new feature branch whose name is checked before git is asked. The question card is a single quiet line, and the "work wrapped up" bar is gone — the pill's count says the same thing. The pull request used to hide behind a button labelled Merge; both follow the repository's real default branch rather than assuming main.
After a merge, the branch can go. A notification offers to delete the merged branch — locally only, with git branch -d, so git itself refuses if the merge did not contain it; a copy on the remote is left alone. Merging a branch you are not on puts the checkout back where it was, and a conflict is aborted rather than left in the tree.
Pull requests for Azure DevOps, and without gh. A pull request is gh pr create where that works, and otherwise the provider's own page with both branches already chosen: GitHub's compare page or Azure DevOps' pull-request-create. Any other host gets the branch pushed and is told so. A task's Open PR in the merge queue uses the same route; it used to be gh or nothing.
Merge strategy has its own settings group. Settings → Behaviour → Branches & merging, not under "Team Work". With the buttons saying which they mean, the setting now only decides for the command palette and the Control API.
Named provider keys. A provider keeps its default key and can hold further named ones, each with its own endpoint — a work key and a personal one, or two gateways. Team members and specialists choose theirs with a Key select, and a named key that is missing on a machine fails the agent's start by name rather than quietly falling back to the default. Settings → Models and the This machine wizard's Keys step share one card. Saving a member also kept dropping a hosted member's endpoint; it no longer does. The facilitator role backends and the conflict resolver still use the default key.
Agent CLIs as the memory backend. memory.semanticBackend takes Claude Code, Codex, Copilot and Antigravity. Claude Code runs on graphify's own claude-cli backend and was verified end to end; the other three go through a loopback bridge with a one-shot agent per chunk, are unit-tested, and have not yet been run against the real CLIs. None of them is ever picked by auto. Unsloth, which Settings offered and the host ignored, is a real backend now.
Routines: templates, and a timetable you can read. The Routines page opens with nine templates — a daily review, a morning brief, a security review, a dependency audit and others — each a routine worth having, already written. A routine's timetable is asked for the way a calendar asks: a start date, a time, repeat every so many days or weeks on the days you tick, until a date. Cron is still there as a third mode, and is still what runs; the parts cron cannot say ("every second week", "not before", "not after") are checked beside it by the same functions the preview uses, so the two cannot disagree.
Background jobs in the title bar. A routine runs in the desktop's main process, so nothing on screen changed when one started and Run now looked like a button that did nothing. The title bar now shows what is running and for how long, and the last few that finished.
Ctrl+K does things as well as finds them. Before a word is typed it is a command palette: everything the app menu can do, with its shortcut, plus the colour mode. A Commands button and a System / Light / Dark switch sit at the foot of the sidebar.
The office: 35 more characters, and they have names. Forty-one in all. The character picker shows the one chosen by name and opens the rest on demand — those that suit the member's role first, then shelves, a search box, and Surprise me for one nobody on the roster has. A name says what a character is and, where two share a costume, something you can see that tells them apart — "Police officer (ponytail)", "Robot (violet visor)" — never a gender; the team templates name their characters the same way. Also three floors, two wall styles (chosen for the whole office and saved with the layout) and four pieces of furniture.
This machine looks like the project wizard: a rail of steps, a summary of what the machine has, one footer. The pick dialog draws its icon labels as icons and uses the question as its heading.
Memory tells a leftover from a requirement. Git hooks the file watcher has made redundant are no longer shown as "required and healthy". "Open router" is "Open project index".
Projects' numbers are cards. Five tiles in a grid that re-rows by the width of its own pane — five across, three over two, then pairs — instead of a strip that scrolled sideways.
Google Antigravity is detected on Windows. An executable looked up by its full path was never found on Windows: the search joined the path under every PATH entry and then asked where, which refuses a path. The CLI only appeared after a restart, and the ACP server — which lives only in the app's own runtimes folder — never did, however many times it was installed. The same fix makes an absolute command override work on Windows.
A shared-memory GPU is judged on the memory it can use. Windows names the part "AMD Radeon(TM) 8060S", which the unified-memory check did not recognise, so a Strix Halo machine was measured against its 4 GB of dedicated memory. Separately, any card with 4 GB or more read as 4 GB, because AdapterRAM is a 32-bit field; the registry's 64-bit count is used where it is larger.
Clearing a model setting clears it. The editor sends its whole draft and an emptied field is simply absent from it, but the store merged, so the old value came back. A save from the editor now replaces.
Projects: search, sort and a first-project button. Search matches a project's name, its roots' names and paths, and their branch and remote. Sort by activity — what needs you, then what is working, then what you opened last — or by name, newest or most roots. The numbers are there before the first project is, with Create your first project centred underneath.
New folder and Clone offer the places your other roots live. "Or beside an existing root…" lists the folders that already hold roots on the chosen machine, distro or container, most-used first.
The app describes itself as the app. "VS Code bridge" and "the extension" are gone from Settings and its setting descriptions, the Projects page, memory onboarding, the install dialogs, host error messages and the Attributions page.
Vision models bring their projector. A repository's mmproj-*.gguf — the second file that lets a model read images — was listed as if it were a very small quantisation of the model. It is kept apart now, one is chosen (F16 first), and it is downloaded beside whichever file you pick, verified like the weights and passed to the server; the model shows a vision chip. A projector that fails to download leaves a text-only model rather than a failed install.
Option cards in the wizards read like options. The New project, This machine, New team and New specialist wizards laid each choice out as a row — icon, text and tick side by side — which left the text a column two words wide. They are built top to bottom now: a one-line title, a sentence at the card's full width, the status chip on a shared baseline, a filled tick for the selected one, and the option's own icon as tinted artwork behind it.
One look across the views. Chat, Research and Team Work open with the same hero — the mode's tone behind the mark, and three suggestions as cards you can tell apart. Operations' headline numbers, Memory's graph numbers and every "nothing here yet" in Tasks, Plans, Docs, Memory and Architecture use one set of pieces, each view in its own tone; an empty task column says what its emptiness means. Settings pages open with the same header, toned by their group, and are otherwise left as calm as they were. Operations no longer shows "NaN" for a graph that has not been built.
Architecture is back. It had been filed as a developer view of the workbench's own source and hidden behind a setting. It maps whichever repository is open, so it is in the sidebar under Knowledge again.
The built-in browser has a menu item and a shortcut. The globe stays where it is, first on the right-hand rail; it is now also View → Browser, Ctrl+Shift+B and a command in the palette.

0.27.1

The project wizard fits its words. Cards on Where, Source, Prepare and Team cut their text off mid-word, and the "ready" chip sat on top of "This machine". They wrap now, with the chip underneath. The repository URL field's focus outline is no longer clipped on the left.
New folder, made for you. "Empty folder" meant finding the New Folder button in the system dialog. It is now New folder: choose where it goes and a name — suggested from the project's — and the wizard creates it as a local git repository. It refuses a name that already has something in it.
One folder, one project. Picking a folder that was already another project's root quietly made a second project over the same files. The wizard now says so and offers to open that project instead.
No second setup wizard mid-way. A dialog offering the machine setup appeared on top of the wizard straight after Prepare. It is gone from the desktop app; the wizard's Done step offers the rest of the setup instead of "Add another root".
Nothing to adopt, nothing to ask. An empty .mojoup/ folder no longer prompts "Adopt or Start fresh".
Projects tiles. They no longer run into each other or put the arrow on their titles, and on a narrow pane they scroll inside their card. Agents active opens the Office; Approvals opens Mission Control, where waiting requests are allowed or denied; Hosts running is no longer a button that did nothing.
One currency. Spend today switched between AUD and USD. It stays in your currency before the exchange rates arrive, when a host without rates answers, and for a zero that needs no rate at all.
Team and specialist wizards. The runtime and model pickers line up, and a model is named once ("Fable 5.1 · Most capable…", not "Fable 5.1 — Fable 5.1 · …").

0.27.0

One way to start a project. Making a project, adding a root and setting up a machine were five entry points that disagreed about what to check; they are now one wizard, and it can do things the app could not do at all. Paste a GitHub or Azure DevOps URL and it clones into the machine the root will live on — a WSL distro clones inside the distro — with progress as it goes, and an offer to retry in the terminal when signing in needs a prompt. Pick your own repository from a list instead of pasting, once you have signed in. Choose an empty folder and it becomes a git repository, because a root without one has no worktrees; a remote can wait, and the project says "Local only" until you add it.
It checks the machine, not just the folder. Git missing on the target now stops the wizard rather than letting you make a root the agents cannot work in. Missing user.name and user.email are two fields in the wizard, so an agent's commit is no longer attributed to a synthetic name. Docker Desktop has an Install button, and a Start button when it is installed but not running.
A folder is inspected before it becomes a root. The wizard says what it found — a repository and its remotes, a devcontainer.json, and what a .mojoup/ folder brings with it ("2 teams, a board with 14 open tasks, a policy file") — and asks whether to adopt that or start fresh, instead of adopting it in silence. A folder that declares a dev container is offered its container instead of being opened beside it.
Projects is a dashboard. Numbers across every project — hosts running, agents, tasks open and in review, approvals waiting, today's spend — each one pressing through to the view that owns it, and the same numbers per root beside its branch. A root whose folder has moved offers to find it, clone it again or be removed, instead of turning up as a host that will not start.
Sign in to GitHub inside the app. A device-flow sign-in under Settings → Governance → Integrations → Accounts, beside an Azure DevOps card that takes an organisation and a token. The GitHub CLI is still used when it is already signed in.
Azure Boards as a task backend. The local board stays the working store; it can now mirror to Azure Boards work items as well as GitHub Issues, with states mapped to whatever your project actually uses. Task tracking is a settings group per root.
Finding your way. The sidebar groups reads Work, Project, Automation and Knowledge, every view has a line saying what it is for, and the developer-facing views are hidden unless you ask for them. Words the workbench uses and you might not — worktree, operations manager, intent, deviation, SEED, PAUL — explain themselves on hover. Teams says whether each runtime is installed and signed in while you pick it, rather than failing when the agent starts, and offers a pair or a feature squad to start from.
Fixes. A file the workbench watches could lose an edit made in the same moment the watcher started, because two clocks disagreed; it now compares the file with itself. Finding Obsidian's vaults built paths with the wrong separators when the machine being described was not the one asking.

0.26.6

Who reviews the scribe, and whether it lands. "Ask the Scribe" now offers two ways to start: land the work automatically when the scribe finishes, or hold it in Review for you. That choice is kept on the task and beats the specialist's own review setting for that one task. A task waiting for you says so on its card — "waiting for you — open to approve" — with the reason in its tooltip.
Approving lands the work. Approve in the task dialog moved the task to Done and left the branch unmerged, unlike an agent's approval; it now integrates the branch the same way, and says so in the log if it cannot.
The vault follows every graph write. "Keep knowledge memory in the vault" fired only after a code-only update; it now fires after a full rescan and after an update with the semantic pass as well.

0.26.5

The Git view knows whose branch it is. A solo agent whose session had stopped, and a specialist that worked from a task rather than a chat, both showed "unknown — no session found". A branch now resolves to the task that names it (opening the board on that task), else the specialist behind the agent's name with its newest chat, before it gives up; and a specialist's chats are found by its definition, not by a session that has to still be running.

0.26.4

"Ask the Scribe" asks first. Since 0.25.3 the button files a task and starts the scribe on it, which spends its model's tokens. The first click now says exactly that — what is written, who is assigned, that an agent starts — and the second click does it; Cancel does nothing. The queued note no longer says the task waits for the agent's next run.

0.26.3

The team menu handles a long roster. The filter box appears from five teams rather than eight, the list scrolls on its own and never grows past half the window, and the arrow keys walk it with Enter to switch and Escape to close, from the filter box or the list.

0.26.2

A specialist works where its task is. Starting the scribe from "Ask the scribe" or the board's Run put it in an office of its own while the task sat on the solo board. It now starts the way a chat starts it — one solo agent with its own name, character and runtime — on the board that holds the task.
The office's team control scales. A chip per team stopped fitting at six or seven. Now: Home, then the teams with agents in them as chips (the current team always among them), then one menu for the rest, with a filter once there are eight or more.
The tray lists recent projects. Its Projects submenu shows the six most recently opened, then "All projects…", which opens the Projects page with the count of what it left out.

0.26.1

Recordings can be MP4. Settings → General → Built-in browser chooses the container (WebM, or MP4 with H.264) and the frame rate that the toolbar's Record button and an agent's browser_record_start use; an agent can still ask for the other per recording. MP4 plays in chat and mail clients that refuse WebM. It is encoded by the app's own Chromium, and on a build that cannot encode it the recording is written as WebM and says so, rather than failing. The file's extension follows what was actually written.

0.26.0

Record a browser tab as video. A Record button in the built-in browser's toolbar records the tab you are looking at as a WebM file, five frames a second, saved in a folder beside your downloads and listed in the downloads drawer with a Reveal button. Agents have the same: browser_record_start before exercising a feature and browser_record_stop when done, which returns the file's path to cite in the task summary as proof the feature worked. The video is encoded by the desktop's own Chromium, so there is nothing to install; a tab the dialog is not showing still records, because frames are rendered on request rather than waiting for the screen. One recording at a time, and a person can stop an agent's from the toolbar.

0.25.3

Gemini Notebook support removed. It shipped in 0.25.0 and was not wanted: the API is Enterprise-only (the consumer NotebookLM has none), and Obsidian is the notebook. Gone: the Send to Gemini Notebook button on research conversations, the Gemini section of Settings → Research, the Gemini row of the Memory view's Notebooks card and its Send lessons action, and the eight mjuWorkbench.research.gemini.* settings. A stored value for those keys is ignored. Research artifacts, the Obsidian vault and everything else in 0.25 are unchanged.
"Ask the scribe" starts the scribe. The Architecture view's button and the Docs view's refresh button filed a task, put the scribe's name on it, and stopped: Team Work dispatches through the operations manager, and a task filed to a specialist from a view had nobody behind it. Both now start the task the way the board's Run does, and Run itself now finds a specialist's session and starts the specialist when it is not running, instead of saying it is not.

0.25.2

Notebooks have a place in the app. The Memory view gains a Notebooks card: for Obsidian, the vault in use, what the project folder holds (topics, docs, skills, research reports, notes in the Inbox), when it was last written, and buttons to open the vault, open the project's router, and write now; for Gemini Notebook, the project and notebook, how many sources have gone there, and buttons to open the notebook and to send the knowledge lessons as a source, so it holds more than research reports.
Links into the vault. A selected node in the Memory view opens the topic note that holds it in Obsidian. A document the vault mirrors gets an Open in Obsidian button in the Docs view. Both say so when the vault does not carry the thing yet, instead of opening nothing.

0.25.1

The vault's graph view shows topics, not a code map. The first write put 543 notes under Memory/Communities, most of them one node, named after unresolved code references and graphify's own work-memory files that had been counted as knowledge. Those are repo memory now: graphify's graphify-out/ output stays out of the knowledge scope (the vault shows it as the work log and lessons), and a concept the semantic pass minted from code (ref_zod, src_acp_teamconfig_teamscope) is the code's, not shared. On this repository the knowledge scope drops from 2,353 nodes to 1,100 and from 543 communities to 93.
Small communities roll up. A community of fewer than three nodes is a line in Memory/Smaller topics, not a note; at most 80 topics get a note of their own. Community names that were file names read as titles.
An Architecture note. Docs/Architecture is written from docs/architecture.json: the layers, each area under them, each linked to its solution page in the vault. The top router points at it first.
A simpler vault picker. Making the vault in Obsidian and pressing Check again was easier than the create form, so that is the route the card offers first; creating from the app is one field, behind a link.

0.25.0

Research has three shapes, and a critic. The first picker is now Specialist, Team or Council, and the second lists only who can run it. A specialist is one named researcher answering the whole question — the thorough, cheap default that Research never had a way to ask for once the anonymous "one researcher" went. A team still divides the question into topics; a council still puts every member on the whole of it on its own model. Critique sits on any of them: a second model reviews the draft report as an expert reviewer and the author revises it before delivery — the same division Copilot's Researcher makes between Model Council and Critique. Switch it per run in the composer; a team names its reviewer in the Team Builder, a specialist names another specialist, and Settings → Research holds the defaults.
Council compares like a council. Each member now writes a full standalone report that is kept whole, and the lead's summary says where the reports agree, where they diverge, and what each uniquely contributes, attributed by member and model, rather than blending them into one answer.
Research artifacts. A finished run is written in the formats you pick: an OKF note (typed Markdown the Docs view reads and memory indexes), plain Markdown with notebook front matter, and a self-contained HTML page that reads in any browser, light or dark. The report carries the standalone reports, the challenges and the critique as appendices. An artifacts bar on the conversation opens each one, shows it in its folder, and hands it to Team Work: the new session reads the artifact and plans the work it recommends, asking about its open questions first.
Two memories: repo and knowledge. The memory graph is now read as two: repo (code, symbols, relationships) and knowledge (docs, decisions, plans, threat models, research, instruction files, and any folder you add in mjuWorkbench.memory.knowledge.sources). Mixed together the sparse knowledge nodes lost — the security model's sections sat in a community named after a code file. Every memory tool takes a scope (repo, knowledge, all); the Memory view's Ask box has the switch and the lifecycle panel shows both sizes. Research asks knowledge first, then repo; task dispatch asks repo first; a research artifact's result is saved to knowledge work memory, which has its own lessons. The scoped graphs are derived from the one extraction, never built twice.
Knowledge memory in your Obsidian vault. The vault is the knowledge memory's human face, not a third store: one folder per project (AI Workbench/<repository>, or the folder you name) holds a note per knowledge community with wiki links for the edges between them — so Obsidian's graph view shows the memory's community graph — plus _index.md routers that say what each folder holds and when to read each note, the knowledge lessons, the work log, and the research reports. The knowledge graph is re-clustered on its own before it is written, so communities are knowledge-shaped. Only notes the workbench generated are ever replaced; your Inbox/ there is read, never written. Sync from the Memory view, or after every memory update with research.obsidian.syncKnowledge.
Knowledge folders outside the repository. mjuWorkbench.memory.knowledge.sources names folders whose notes belong to knowledge memory — an Obsidian vault's Inbox, a notes folder, a shared specification directory — and they answer a memory question with scope knowledge alongside the repository's own docs. Settings → Memory → Knowledge sources adds them, by typing a path or browsing on the machine the host runs on; the Memory view says how many notes each contributed and names one it cannot find. Notes the workbench wrote into a vault itself are skipped, so writing knowledge memory to Obsidian never feeds its own output back in.
Promote a note from the vault Inbox. The Memory view lists what is waiting in the vault's Inbox and copies one into the repository under docs/notes/, committed with you as the author and the workbench credited as co-author. The vault note is never changed; the repository copy records where it came from, which is also what stops the original being indexed twice.
The vault carries the repository's docs and skills. Writing knowledge memory to Obsidian now also mirrors the documents the graph knows into Docs/ and the repository's skills into Skills/, each with its own router, so a community note links to something you can read in the vault instead of naming a repository path. They are copies: the repository is where they are edited, and every mirrored note says so. mjuWorkbench.research.obsidian.mirrorDocs turns the docs mirror off.
Obsidian set up from inside the app. Settings → Research and the Setup wizard's new Vault step find Obsidian and list the vaults it knows — read from Obsidian's own registry, through /mnt/c when the host runs in WSL, with every path translated for the host — so a vault is picked, not typed. Create one when none fits: a folder with the .obsidian marker, under the Windows user's Documents from a WSL host so Obsidian on Windows can open it, then opened in Obsidian, which registers it. A "Write to Obsidian now" button does the first write. The desktop had refused every non-http link, so obsidian:// had never opened from it; it now allows that one scheme and no other.
Notebooks. Send a report to an Obsidian vault (a file write into the folder you name, then an obsidian:// link opens it) or to a Gemini Notebook (NotebookLM Enterprise, through its API: the report becomes a text source in a notebook the workbench creates and remembers, with the bearer token minted by gcloud on each call and never stored). Either can be sent by button or on every run. Settings → Research & notebooks is the new page for all of it; the Team Builder gains the critique controls.

0.24.9

Codex says whose account it is on. Only Claude Code was listed as a runtime that pays with its own sign-in, so Codex had no "signed-in account" option to select and its provider picker fell through to the OpenRouter default — reading "OpenRouter" while the models beside it were Codex's own and nothing was routed through OpenRouter at all. It now shows the ChatGPT account it actually uses, and choosing a provider still switches to that provider, because that is where it is then routed.
And how to sign it in. The line under that picker was written for one runtime, so every other runtime reaching it told you to run claude and /login. Each now names its own CLI. Antigravity gains the account label for its summary line but deliberately no sign-in hint: it has no provider picker for one to appear in, since its adapter takes no base URL and cannot be routed through a gateway.

0.24.8

Codex and Antigravity list the models they will actually run. Codex was offered OpenRouter's entire catalogue — several hundred models, none of which Codex on its own sign-in can run, so picking one produced a config that simply failed. Antigravity was offered nothing, under a label claiming the field did not work; it did. Asked over ACP, both answer: Codex with gpt-6-astra[high] and its siblings, Antigravity with gemini-3.8-flash-high and its. The probe that already did this for Claude Code — start the adapter, open one session, read the list, shut it down, no prompt sent and no tokens spent — now serves all three, and Refresh beside the model field is what asks. Pointing Codex at a hosted provider still lists that provider's models, because that is where it is then routed.
The model picker scrolls. The new-team wizard offered models through a <datalist>, whose popup Chromium does not scroll: with a backend reporting hundreds of models, everything past the first screenful was unreachable. It is the same dropdown the Team Builder uses now, and a model the backend did not list — a signed-in alias, or one saved while a server was down — is still offered rather than silently dropped.
The browser fills its empty tab. Opening a page always made a new one, so the blank tab you start with sat untouched while pages piled up beside it. The tab in front of you is preferred to one hidden behind it, and a tab mid-navigation is left alone.
Tablet and mobile can be turned. Landscape swaps the axes, which is a different breakpoint and often where a responsive layout actually breaks — 844px wide is not 390px. The device keeps its scale factor and touch flags when rotated. Agents get it too: browser_emulate takes an orientation.
A clicked ref that has gone says so. Chrome's "Could not compute box model" reached the agent unchanged: a symptom, no cause, no action, from a tool whose description promises it scrolls first. A click now scrolls, retries briefly, and then explains the likeliest reason — a busy page replaces elements while you read it, and a detached node never gets a box back — and says to take a fresh snapshot.
Images render in the markdown preview. A README saying <img src="media/logo.png"> means "beside this file", and the preview did not know which file it was showing, so the path resolved against the app's own origin and nothing appeared — in markdown and HTML alike. The bytes are now read from the workspace and inlined. A root-relative /logo.png and a path climbing out of the workspace are refused rather than guessed at, since either would quietly show a different image than the one written.

0.24.7

A tool's answer reaches the agent. browser_snapshot still came back as a bare header — a url, a title and a ref count — even once the accessibility tree was being read correctly, and the agent fell back to scraping raw DOM on a tree that was sitting right there. The tree travels in the result's text; a small header travels in its data; and the sidecar was sending both, the second as structuredContent. That field pairs with an outputSchema in the MCP spec, and a client seeing it on a tool that declares none may render it INSTEAD of the text. It now goes only to the tools that have an app to draw it — the task board's two. Every browser tool set data and none of them has a UI, so the same silent truncation applied to all of them; snapshot is simply where losing the text was fatal rather than merely lossy.

0.24.6

A page snapshot reads the page you are looking at. browser_snapshot came back as a bare header — a url, a title and a ref count, with no page text and nothing to click — and the agent fell back to reading raw DOM. Chrome answers an accessibility-tree request from whatever document is currently attached, and after a navigation that is the PREVIOUS one until the new document commits. Measured at around 200ms on a heavy news site from a cold load; inside that window the tree is about:blank, which is two nodes and no text. The snapshot now waits for the tree to say it is about this page, and says so in the reply if it runs out of patience rather than handing back a thin tree that reads like an empty page. Waiting for the page to finish loading would have been the wrong fix: an ad-heavy page stays loading long after the tree is ready.
A chat with a specialist keeps their name and face. The transcript looked the agent up in the list of running sessions, and a stopped agent leaves that list — so the moment a turn finished, every message in the conversation, including the ones on screen, fell back to the word "Agent" and an initial in a circle. The name, colour and character now come from the specialist the conversation is with, which does not stop existing when its agent does.
Reload, hard reload, and three viewports. The browser's reload button now says what it does, and Shift-clicking it bypasses the cache the way it does in every other browser — a soft reload will happily serve the stylesheet you just changed. Beside it, a switch between desktop, tablet (820 x 1180) and mobile (390 x 844): mobile also sets the touch flags, so a layout that branches on pointer type rather than width is rendered the way a phone actually gets it instead of merely being narrowed. Desktop clears the override, so the page goes back to the size of its own pane. Agents can ask for both: browser_reload takes hard, and browser_emulate is new.

0.24.5

Agents come back on the runtime they were running. A saved session recorded the agent's identity and its model but never its runtime, so on restore the spawn fell through to the default — Copilot CLI. Every solo agent and every specialist therefore returned as Copilot after a restart or an in-place update, still carrying the model id of the runtime it used to be on: a specialist on Claude Code came back as Copilot and then failed to set opus[1m], because Copilot has no such model. The session looked fine and answered, and had none of its runtime's tools — which is how it was found, as an agent reporting that the integrated browser tools did not exist. The snapshot now keeps the spawn inputs and they are resolved again on restore, never the resolved spec, which carries API keys in its environment. A runtime that has since been disabled or uninstalled says so instead of quietly landing the agent somewhere else. Plain chat had the same gap by a different route — it passed no runtime at all — so facilitator.chatRuntime was ignored on every chat that did not go through a specialist.
The author of a commit is you. Every commit the workbench made on your behalf carried -c user.name=Mojo Up, which put a synthetic identity in the author field and climbed the repository's contributor list. Authorship is the record of who is accountable for a change, and that is the person whose account and machine produced it. The agent or the app is credited with a Co-authored-by: trailer instead, carrying the agent's name and its team. The old identity survives only as a fallback for a machine with no git identity configured at all, where the alternative is git refusing the commit and the work an auto-commit exists to preserve being lost. Agents are also told, in their priming and in AGENTS.md, never to pass --author or set GIT_AUTHOR_* — which is where the commits authored "Tahlia" came from, not from any code of ours.
"Detect Windows host" works on Unsloth Desktop. The Settings page offers the button for every local runner it lists, but the inbound message schema knew only Ollama and LM Studio, so pressing it on Unsloth posted a message that was rejected and dropped — no error, no effect, nothing on screen. The handler behind it was hardcoded to the same two. Both now read one table of local runners, so a runner the page offers the button for cannot be missing from the logic.

0.24.4

A specialist's finished work no longer waits for a reviewer who does not exist. task_done always moved a task to review and told the agent it would be checked, but a specialist has no operations manager and no reviewer, so nothing ever checked it: five finished tasks sat in the review column for good and none of the work was merged. Working alone, a task is now completed and its work merged. A specialist can be set to review its own diff first, or to hold every task until you approve it, and whatever it is set to, the agent can still ask you to look at one task when its own judgement says so or when you ask it to in the chat.
Tasks a specialist plans carry its name, its plan and its chat. A specialist chatted to directly runs on the shared solo board, which is not a running team, so every lookup that asked the board which team it belonged to quietly found nothing: assignees were dropped as "unknown", the plan was marked approved whatever the setting said, and no task knew where it came from. Cards now show the agent and a plan chip, and a task opens the conversation that asked for it.
A plan's reference reaches the board. PLAN-1 was assigned on the way to disk, which happens after the tasks are created, so no task ever carried a plan name and the board's filter fell back to the tail of the plan id — the unreadable thing references exist to replace.
Editing a specialist is no longer editing a team. The screen said "Edit Team", "Save Team" and "Remove X from this team" over a single agent, and offered a roster to add to, an operations manager to pick and a research mode to set, none of which apply to one. In their place is the question that does: who checks its work.
The new-specialist wizard picks characters and finds models. The character was a sprite you had to discover was clickable, cycling blindly through ten of however many are loaded; it is now the same grid the Team Builder has. The model was an empty box you typed a remembered id into; it now lists what the chosen backend actually serves, and says plainly that the workbench default is the GitHub Copilot CLI.
Two roles for the agent you talk to rather than the one you dispatch to: Debugger, which chases a fault to its cause and proves the fix, and Generalist, which works in conversation and reaches for the board only when the work earns it.
A specialist shows its character in chat. The transcript drew an initial in a circle for exactly the agents that have a character chosen for them, because it looked the sprite up by team and a specialist chat has none.
Sessions can be renamed. A chat, research or Team Work session was named after its first message for ever, which reads fine that day and tells you nothing a week later. Click the name to change it. The Scheduled button has left those pages — recurring work is Routines' job, and two doors onto the same schedules meant two places to keep in step.
Being watched remotely is visible even for a glance. A single captured frame holds the mirror open for about a second — less than it takes the badge to paint — so a one-off capture was effectively silent, which is the exact case the indicator exists for. It now stays for twelve seconds and says when the viewer has gone.

0.24.3

The worktree window's checkout picker no longer spills across the screen. Its menu was not inside a popover, so instead of a list under the button it rendered inline at full width, painting branch names over the page behind it. The editor's empty state also said to pick a file "in the Files panel on the right" while this window puts it on the left, and a file that cannot be shown offered to open it in an external editor even for a branch, which is read from git and is not a file on disk.

0.24.2

Open a worktree in the app. Open on a worktree row now opens a window inside the workbench — the file explorer and the editor pointed at that checkout — instead of only handing the folder to an external editor, which is still there as Externally. The same window browses a branch: pick one from its strip and it is read straight out of git, with no checkout, which is why that view is read-only — a ref is not a working tree and there is nowhere a save could go. When an agent is working in a worktree the window says so, because its next auto-commit takes whatever is in the tree, including your edit.
Every branch is visible, switchable and deletable. The Git page has a Branches table: what each one is, how far ahead or behind, its last commit, and buttons to open, switch to or delete it. Ordinary branches were invisible before — the git model dropped anything that was neither the base nor one of ours unless it had a worktree, so a feat/… branch could not be listed, let alone acted on. The model reports them all now and the graph keeps its own filter, which is where that choice belonged. Switching is refused, with the reason, when the checkout has uncommitted work or a worktree already holds the branch; deleting is refused for the branch you are on and for one with a worktree, and an unmerged branch asks before it is forced.
Files messages carry a scope. Internally, the explorer and the editor used to assume one directory — the project root — and every path was relative to it. They now name a checkout (project, worktree:<branch> or branch:<ref>), which the host resolves against trees git itself reports, so the renderer still never says where on the filesystem anything is. An editor tab carries its checkout too, so the same relative path open in two of them is two tabs rather than one showing the wrong file.
A specialist is a definition, not a team. It was a TeamConfig with one member, which meant it quietly had everything a team has: a Start button, a board keyed by its id, and a mojoup/<specialist>/<name> worktree. So a specialist could be handed work on a board nobody watched and that the specialist itself never read — it reads its team's board in a team and solo by itself. Specialists no longer start, no longer appear in the task board picker, and role-routed work now lands on the board that asked for it, assigned by name. Using one in a team is unchanged and always worked: it is an ordinary member of that team, on that team's board, with its own branch, its own worktree and its own running instance — add the same specialist to two teams and they are two of each, independent, with mojoup/solo/<name> for its own work besides.
Chatting to a specialist is solo work. It used to borrow the board of whichever team was listed first among those using it, which is arbitrary once two teams share one, and put your own conversation on a board a team was running against. It is the solo board now, whoever else uses it.
Worktree rows say commits, in words. The divergence column read +0 / −351, which is the shape of a diffstat — so a branch simply 351 commits behind main looked like 351 deleted lines sitting in the worktree. It now reads "351 behind", "3 ahead · 5 behind" or "in step", uncommitted work is spelled out rather than abbreviated to "dirty", and a branch with nothing of its own that has fallen a long way back is marked stale, since deleting that one loses nothing.
Open on a worktree row says why it failed. It could do nothing at all: the OS opener reports failure by returning a message rather than throwing and that message was discarded, while a detached editor launch fails after the call has returned and had nowhere to report to. Both now say what went wrong, and which editor could not be run.

0.24.1

Somewhere to put an API key. Every endpoint that authenticates now has a field to type its key into: hosted providers in one list under Settings → Inference gateways, and a local server that authenticates beside its own endpoint under Agent backends. There was no such field before — a key could only be typed into a modal behind a button called "Set provider API key…", and the list behind that button was filtered to non-local providers. Unsloth Desktop, which authenticates every request including its model list, was therefore shipped with a key the spawn path carried, the proxy would have delivered and nobody could enter. Whether an endpoint takes a key is now asked as its own question rather than inferred from whether it is local: Unsloth requires one, LM Studio takes one if you switched authentication on under Developer → Server Settings, llama.cpp and vLLM the same, Ollama never. Each row says which it is, and a provider that requires a key refuses to start an agent without one instead of spawning a session that answers 401 on every turn.
Keys say where they live. A key is kept in the operating system's keychain, never in a settings file, and never put in an agent's environment — the local proxy adds the header. Each row says so, and it is never read back out: the field is empty whatever is stored, and the app is only ever told whether a key is there. Storing one with the local proxy switched off used to be a trap, since the proxy is what carries it; the rows now warn, and offer to turn it on.
Updates stops checking what it cannot check. LM Studio and Unsloth Desktop report no version and publish no releases, so their rows sat in the pane saying "not checked" forever and trained the eye to skip it. They are gone (and no longer probed on every refresh); whether such a server is running belongs beside its endpoint in Settings. Antigravity has arrived in their place: it was absent because the pane was built from npm packages and its CLI comes from Google, so it now appears with a line saying the CLI updates itself and the ACP server is pinned by this version of the app.
Settings stopped mentioning VS Code where there is none. The Azure key setting said keys live in "VS Code secret storage", the theme setting was "independent of the VS Code theme", several descriptions told you to run a command-palette entry the desktop app has no palette for, and "All VS Code settings…" was offered in a window with no editor behind it. Each now names where the thing actually is.

0.24.0

Research asks two questions instead of one. The first picker is the shape of the run — Team or Council — and the second lists only the teams that can do it. A team divides the question into topics and covers more ground; a council puts every member on the whole question, each on its own model, without letting them see each other first, and then they argue. A team declares which it is in the Team Builder, so a council never turns up under Team and the list never offers something that cannot do what you picked. The anonymous "one researcher" is gone: it was an agent nothing had configured, and when an answer came back there was no saying who wrote it.
mjuWorkbench.git.pushAfterLanding. Landing was entirely local: agent branches, the integration branch and the fast-forward onto the default branch never touched a remote, so after a team's work landed your checkout was ahead of origin until you pushed by hand. Turn this on and the branch it landed on is pushed, with the result in the same note. Off by default, because pushing is the one step in this flow other people see. A push that fails says so and leaves the work landed rather than stranding it.
An update offers the version that can actually arrive. Claude Code from winget was offered 2.1.278 from the npm registry while winget's catalogue had 2.1.268, so the row could never go quiet however many times it was updated. The newest version is now read from whichever package manager owns the installed copy, each line says where its number came from, and the same package under two owners — npm's copy in a distro, winget's on Windows — is no longer cached as one.

0.23.1

A Git branch a specialist is working on names the specialist. A branch like mojoup/scribe/shakespeare was listed as "unknown" with "no session found", because the lookup only searched Team Work runs and a specialist has none. It now resolves to the conversation the specialist is holding, or to the specialist itself when it has not started one.
The Research composer no longer shows two team pickers. The Team Work controls were drawn whenever the surface was not Chat, so Research got a second, permanently empty team dropdown and a "Shape first" button beside its own picker. Its options also say what they do now: "Just me and one agent" rather than "One researcher", and each team shows how many members hold a research role, so a team that would answer with one voice says so before you pick it.
A CLI installed by a package manager is updated by that package manager. Claude Code from winget ignored both claude update and npm, so the pane offered 2.1.278 forever and the CLI kept reporting what winget had put there. The Update button now runs winget upgrade (and Homebrew, Scoop or Chocolatey where those own the copy), reading the package id out of the install path. When that manager is simply behind npm, the result says so — "updated to 2.1.268, the newest winget has; 2.1.278 is published" — instead of reporting a working upgrade as a failure.
Fixed the two tests that had been failing CI on macOS every run. A file watcher announced every pre-existing file as changed on macOS, because the guard against that compared whole-millisecond Date.now() against a nanosecond filesystem timestamp; a file written in the same millisecond the watcher started looked newer than the start. The other was a test that hardcoded where gh keeps its downloaded Copilot binary, which is a different folder on macOS.

0.23.0

Research is a team that argues with itself. Pick a team in Research and the question is split across its researchers — each takes one topic, they investigate in parallel, then every one of them reads the others' findings and says where it agrees, where it does not, and what would settle the point. The lead reconciles them into one answer: what everyone supports, what is contested with the strongest case each way, and a recommendation. Because members carry their own runtimes, that is several models comparing opinions, not one model asked three times. Each contribution lands in the conversation as it arrives, attributed to the researcher and its model, and the reconciled answer is what gets filed as the research note. Without a team it is one researcher answering alone, as before.
A team can say how research is broken up. The team editor takes topics — architecture, UI, process, whatever the work needs — each with an optional brief and an owner, plus how many rounds of challenge to run (0 skips the argument, 1 is the default, 3 is the most). With no topics, each member with a research-ish role takes one named after its role.
A runtime row says which copy it is talking about. The same CLI is a different install on two roots of one project — npm's inside a WSL distro, the native installer's on Windows — and only one of them is npm's to update. An up-to-date row now names where the CLI on PATH came from, and one that is installed but will not report its version says that instead of claiming to be current.

0.22.0

Chat runs on a specialist. The composer offered "＋ New agent", which spawned an anonymous agent configured by nothing. It now lists the specialists you have defined: picking one starts that agent with its own name, character, model and instructions, and the conversation remembers which specialist rather than a copy of its settings, so editing it in Teams changes the next turn too. A specialist works on the board of the team that uses it, and on solo when no team does.
Team Work no longer invents a team. It used to mint one per conversation from the facilitator settings, which left a drawer of facilitator-ops-* teams nobody designed, each with its own board, and made "which team did that work?" unanswerable. A run now belongs to a team you defined: with exactly one team that has an operations manager it uses that, otherwise it asks you to pick. Conversations already bound to a generated team keep working — those are ordinary team files — and the scheduler asks for a real team too.
The Updates pane stops looking empty. It asked the host for its own machine's state once, at start-up, so a request made before the host was attached was simply lost: the pane showed the app alone however many times you pressed Check now. It now asks whenever the pane is opened, whenever a host becomes ready and after a project switch, and an empty group says whether it is still checking or has nothing rather than vanishing. Unread release notes no longer count as "1 update waiting", which made it look as though reading them was a prerequisite.

0.21.0

Unsloth Desktop is a model runner, like Ollama and LM Studio. Turn it on in Settings → Local models, point it at the port Unsloth booted on (8000 by default), and it is there as a backend for any team member, with its model list in the picker. It differs from the other two in one way that matters: it authenticates every request, so store the key made in Unsloth under Settings → API with Mojo Up: Set LLM Provider API Key (provider unsloth). The key travels in the local proxy's route, never in an agent's environment, and a key with the proxy switched off is refused rather than spawned to fail on every turn. It also appears as a model server in the Updates pane.
A CLI that updates itself is updated by its own command. Claude Code's native installer has been the default since 2.1.113 and the npm package is deprecated, so npm install -g changed a copy the CLI never reads — which is why an update reported success and the version stayed put. Updating Claude Code now runs claude update for the CLI and npm only for its ACP adapter, and when something still does not move, the row says which version is published against what the CLI reports.

0.20.0

An update says what it actually moved, and admits when it moved nothing. The success line read the runtime's version, which for a CLI driven through an ACP adapter is the adapter's — so updating Claude Code from 2.1.274 to 2.1.278 announced "updated to 0.79". It now names the packages that changed. And when the CLI on PATH came from winget, Homebrew or its own installer, npm install -g installs a second copy and changes nothing: that is now said before the terminal opens, and afterwards the row reports what npm has against what the CLI still reports, with the path it came from, instead of claiming success.
Find and replace has its icons. The widget draws them from Monaco's own icon font, whose stylesheet the package does not export — the import never resolved, so every toggle was an empty box.
Specialists: one agent, defined once, reusable by every team. Most standing agents are a single agent — a scribe, a reviewer, a researcher — and wrapping one in a "team" read as the workaround it was. A specialist is defined like a team, in the same three scopes, through the same wizard (with the roster and orchestration steps left out, because one agent has nobody to delegate to). Teams shows them under their own heading.
A team can take a specialist as a member, and the settings stay in one place. Adding one stores a reference, not a copy: change the specialist's instructions, model or runtime and every team using it follows. The member is shown in the team editor with a link to where it is defined rather than fields that would drift. A specialist card lists the teams holding it, and deleting one that a team still uses is refused with the names of the teams in the way.
The Scribe can actually be found. "Ask the Scribe" looked only at the board it was asked from — the Architecture view asks from solo, which has no members — so the task was filed unassigned while a scribe sat in a team two clicks away. It now looks across every definition the root can see, prefers a specialist, and creates the task on the board its owner actually reads.
The operations manager is never isolated in a worktree. It plans, hands work out and reviews what comes back, all of which means reading the integration branch and the other members' worktrees; in a checkout of its own it reviews a copy of the past and approves against it. The setting is now forced off for whoever holds the role, whatever a config file says.

0.19.5

Check now looks again at what is installed. It re-asked npm but never re-probed the machine, so a CLI updated from the pane kept showing the version detected when the app started — right until the app was restarted. A forced check now re-detects as well, and an install re-attaches the npm versions afterwards, so the row settles on "up to date" instead of "not checked against npm yet".
Recent projects are in the taskbar menu. Right-clicking the taskbar icon lists the projects most recently opened above the fixed actions; each opens that project in a window of its own. The list follows the order the app already keeps and is rebuilt whenever projects change.

0.19.4

A terminal belongs to the window that opened it. The shell profiles a window offered, and the root a new terminal was recorded against, both came from the app's globally active root. That is only right for a window that follows it: a window opened on a project of its own offered another project's profiles and filed its shells under another project's root, where they then appeared — in every window showing that project, and not in the one they were typed in. Both now answer the window that asked, and the renderer names its own root as well, so the two sides agree.
A root setup install is filed under the root it is setting up. It ran with no root at all, and a terminal with no root shows in every project's strip.
CI no longer packages a VSIX. The extension is not shipped that way any more, and the packaging step was the only failing job.

0.19.3

Update actually updates. The Update button ran whatever command detection carried, and detection only carries one while something is missing — so updating an agent CLI either installed its ACP adapter instead of the CLI, or answered "it is already set up" and did nothing. The command is now built from what the check found: npm install -g with exactly the packages that are behind, pinned to exactly the versions the pane offered, whether that is the CLI, its adapter, or both. The confirmation says Update, the terminal is named after it, and the result says what it is on now instead of telling you where to find it.
A re-detect no longer hides an update. Detection is cached for a minute and rebuilds each runtime's package list from what is on disk, which dropped the npm versions a separate check had put there; clicking Update in that window found nothing to do. The installer now asks npm first, from a six-hour cache, so the answer costs nothing in the ordinary case.

0.19.2

One npm package is one row. Ollama, LM Studio and the hosted gateway run models through Copilot CLI's BYOK mode, so the workbench detects them with Copilot's own detector: the pane listed the same @github/copilot update four times over, and three of those Update buttons answered "it is already set up" because only Copilot itself has an install command. Rows are now collapsed by the package they are really about, named after the CLI that provides it and updated through it.
The terminal an update opens says what it is for. It was named after the runtime alone — "Mojo Up: GitHub Copilot CLI" — which told you which CLI and nothing about why a terminal had just appeared. It now names the errand and the versions it is moving between ("update GitHub Copilot CLI 1.0.86 → 1.0.90", "install adapter for Google Antigravity", "update Node (Node.js)"), so a tab you come back to an hour later still explains itself. When a CLI is current and only its ACP adapter is behind, the adapter's versions are the ones named.
The Updates pane is grouped by who does the updating. This app (installs itself), Agent CLIs (npm), Models (the bundled runner and the servers you installed), Memory (the graph engine) and This machine (the prerequisites where the agents run). Each heading carries a count of what is waiting in it, and the order is fixed so rows do not move under the pointer as states change.

0.19.1

Every update in the pane, including the ones only the host can see. The memory engine (graphify) is there with its PyPI version and an Upgrade, and it no longer opens a modal of its own once a day. The machine's prerequisites are there: what is missing, what is too old, and the install that fixes it — with everything that is present collapsed into one line. The bundled llama.cpp runner says which build the app pins and offers to set itself up. Ollama reports its version and says when a newer one is out; LM Studio says it is running and that it reports no version, rather than pretending to be current.
The pane no longer claims things are current when nobody has checked. An agent CLI that has not been compared against npm says so, and the endpoints that are not npm packages at all — Ollama, LM Studio, a hosted gateway — are no longer listed as runtimes carrying another CLI's version. A CLI that prints a sentence for --version shows the version in it. Adapters are checked alongside their CLI and named when they are behind.
The operating system tells you when the app is not in front. A permission waiting on you, an update available or ready, a host that failed, and a host's warnings while you were elsewhere all raise a desktop notification, throttled so a burst is one notification. mjuWorkbench.notifications.os chooses between only-when-unfocused (the default), always and never.
The taskbar icon stopped blinking. Its status dot was repainted on every host status update, and Windows redraws the button on each call. Green means agents are running.
A second window follows its own project switch. Switching project in a window opened on a project of its own moved the main window instead of that one, because the switch went through the app's global one.
Find and replace in the editor has its icons. Monaco's find widget draws them from its own icon font, which the editor core does not load.
Tooltips appear. They were waiting 700 ms, which on a strip of icons reads as no tooltip at all; they now appear in 250 ms, everywhere, and the Files pane, the file search and the Projects view have them on every action.
Manage projects opens the Projects view, which does everything the old dialog did and shows hosts and agents besides; the dialog is gone.
The Architecture map can fill the window, and its descriptions fold away. "Edit descriptions" opens the file in the built-in editor instead of asking an external editor that may not be there, the Scribe can be asked to update the descriptions after they exist rather than only before, and the panel says plainly that the map is read from the code while the words are not.

0.19.0

Teams live in three places now. A team is stored in the repository (.mojoup/teams/, as before), in the desktop project — every root of it sees it — or globally, for every project on the machine. The last two ride in the teams.definitions setting at the project and global layers, so they reach a host inside a WSL distro or a container the same way any setting does. The Teams view groups teams by scope, filters by it, and the builder saves to (or moves a team to) the scope you pick.
A team wizard. "New Team…" walks through basics (name, scope, a template or a blank slate), members (name, role with its instructions, runtime, model, character), orchestration (the operations manager, automatic dispatch, review rounds), policies (tool approvals, worktrees) and a review of what will be created. Templates come with the role catalogue so a role picked later gets its instructions too.
A Projects view and a root setup wizard. Projects shows every project and root with its target, git status, host state, running agents and pending approvals, with open / new window / restart / stop / remove on each row. "Set up a root…" (also on the welcome screen and in the switcher) chooses where the code lives — this machine, a WSL distro, a dev container — says what that kind still needs (WSL, a distro, git, Docker, the Dev Containers CLI) with a button that installs it in the integrated terminal, picks the folder, then prepares the workbench host installer-style: a spinner, one line of status and "Show installation details" with every step the desktop takes (provision-progress), and finally checks the tools and agent CLIs on the root's own machine.
Search everything (Ctrl+K). The title-bar search now asks every store at once — conversations, tasks, plans, files by name, docs, teams, memory nodes, settings pages and views — grouped by kind, keyboard-driven, each hit landing where it belongs. The history-only search remains in Settings.
Search in files (Ctrl+Shift+F). The Files panel has a search mode: match case, whole word, regex, include / exclude globs, results grouped by file with the hit highlighted, a click opening the editor at that line. Replace all across the ticked files, or in one file, with $1 groups for a regex. The file set is what git would show (untracked in, ignored out); binaries and files over 1 MB are skipped. The editor's own find and replace (Ctrl+F / Ctrl+H) work now — Monaco's find contribution was never loaded — and have toolbar buttons.
One Updates pane. The app's own updater, the agent CLIs and their adapters, this root's host (when it is on an older bundle than the app) and the unread release notes are one list in the dock, each with its action, a "Check now" for every source, when the last check was, and how often the app checks by itself (updates.checkIntervalHours, default daily, 0 for never). The dock tab counts what needs you. "Check for Updates…" in the menu opens the pane instead of a native dialog; download progress is reported per percent.
Status on the taskbar and in the tray. The Windows taskbar button carries an overlay dot and the tray icon a corner dot — amber when a permission waits on you, green while agents work, red when a host failed — with the count in the tooltip and the macOS dock badge. The taskbar's right-click jump list and the tray menu offer New window, Start an agent, Stop all agents, Approve next permission and Updates.

0.18.17

A finished plan is closed out once. When a Team Work run's tasks are all done, the conversation gets the run summary, the operations manager's outcome report (every success check verified with evidence) and the unify note — by design. But a run picked up again after that — the team started after a restart, or the request re-sent — asked the operations manager to verify the same checks again and posted a second report. The report is now asked for once per intent (the step says "already reported … not asked again"), a run whose tasks were all done before it began ends with one line ("Nothing left to do — the N task(s) of this run were already done"), and a planning turn that proposes nothing when every task from the conversation is done says that, instead of hinting that a clarifying question may be waiting above.

0.18.16

The file heat map reads like one. Tiles go from the plain surface through amber to red as activity climbs — one hue family, so paler always means less — and each tile carries its own numbers (✎ edits and commits, +added in green, −removed in red, reads for files only looked at), so the colour is never a guess. The tooltip uses the same colours.
Click a file for its details. A dialog with the counts as chips, who touched it and how often, the tasks it belonged to, first and last touched, and three actions: Show events (the history filtered to that file), Open file (in the editor pane) and Open changes — the diff viewer showing what this run or task did to the file, from the last commit before the run began to the working tree (or to the end of a finished task). That is a new git-file-diff request on the host.

0.18.15

Agent history has a file heat map. A Files view beside Events: every file the run's agents read, edited or committed, as tiles grouped by directory and shaded by how much happened to each (edits and commits weigh more than reads). The tooltip says what, how often and by whom; clicking a tile searches the events for that file. Commits are attributed through the task named in the subject, because agents commit under your git identity. The same view exists for one task from the board.
Every edit and read is recorded now. Claude Code names the file in a tool call's raw input far more often than in the ACP locations field — one call in twenty carried it — so the heat maps, "files changed" and Mission Control's live heat map saw almost nothing. Locations are derived from the input and from diff blocks; a run from before this version says so in its Files view rather than looking quiet.
The left rail remembers whether it was collapsed. The component library keeps that in a cookie the desktop's app:// origin does not persist; the shell stores it itself.
Team Work chat: no more "working…" on an idle agent. The CLI's banners outside any turn ("Info: Disabled tools: …" on a resume, a rate-limit notice) were narrated as an active bubble that nothing ever closed. They are no longer narrated, and an agent's bubble settles when its turn ends or its session stops or errors.

0.18.14

The agents table and the request log answer the question you brought. Both were flat tables you read top to bottom. The Operations agents table is a data grid now: sort by cost, tokens or context to find the agent running away with them, and the name column stays pinned while the other ten scroll, so a figure never belongs to nobody. It totals the fleet in a footer — spend converted into your display currency, and it says so when a missing rate leaves an agent out rather than quietly making the run look cheaper. The Inference dock's request log shows all of the last 200 requests instead of the newest twelve, sorted on real durations and token counts rather than the text of them, with the failures counted beneath it.
Component library update. The interface's component library and the packages it requires moved to their next beta; one dependency it no longer needs is gone.
Agent history shows it is working. Opening the panel on a long run takes a few seconds while the host reads every member's archive; the panel now shows a spinner with "Loading history…" for that time, and clears the previous task's events the moment you switch to another, instead of leaving stale rows or a bare line of text.

0.18.13

Agent history shows the run again. A Team Work conversation's history is every member's archived event since the run began; after four days that reply was 59 MB — mostly the full text of every dispatch prompt — and the host link refuses frames over 40 MB, so the panel never heard back and said "No agent activity captured" for a run with thirty thousand events. The reply is bounded now: long fields are clipped to 2,000 characters (the panel summarises them anyway), the oldest events go until the rest fits in 6 MB and 4,000 events, and the panel says how many were left out and where they still are. It also says "Loading history…" until the reply arrives instead of claiming there is nothing.

0.18.12

A Team Work task now completes end to end without a person, including across an app restart and an external commit to main. One test drives all of it against a real repository: dispatch, work, approve, integrate, land; a restart with work in flight; a conflicting commit on main; a merge held behind that conflict.

A restart resumes work instead of asking. Tasks in flight when the app came back raised a Resume / Park dialog; dismissed, or with nobody at the screen, it parked them and the team stayed stopped until someone noticed. They are resumed now: an assignee who is back is asked where they got to, one who is not has the task requeued so it dispatches the moment they return. Stopping is what the Stop button is for.
An external commit on main that conflicts goes to the resolver. The integration branch could not take main, landing reported "it conflicts right now" for ever, and — worse — the next approval merged its branch straight into your checkout, around the conflict. The conflict now goes to the configured merge resolver in the integration worktree; nothing is merged around it; and the message names the cause.
A held merge is retried. An approval refused because of that conflict left the task done, approved and never integrated, with nothing that would try again. It is retried immediately after a landing (when base and integration agree once more) and otherwise on a backoff from five minutes to an hour.
CI is green on all three platforms. The macOS watcher echoed a pre-existing file whose mtime equalled the watcher's start; the Copilot detection test found the runner's real gh in /usr/local/bin; the installer test asserted an execute bit NTFS does not have; two review-tree tests compared CRLF to LF; a temp directory was removed while git still held it.

0.18.11

The merge flow finishes itself. Approve → integrate → land already ran without a person; it stopped in two places a person then had to notice, and it told nobody.

Landing applies git's rule, not a stricter one. Integrated work is a fast-forward of your checkout, and it was refused whenever any tracked file had an uncommitted change — so approved work sat on the integration branch for days while you edited an unrelated document. It is now refused only when a file you have changed is one the incoming work also changes, and the message names that file. Everything else lands around your edits, which git leaves alone.
Landing retries by itself. It was attempted only at the moment of approval and on the manual button. A sweep now tries once a minute, so work lands the moment your checkout allows it, with no one pressing anything. When it cannot, you are told once, with what is in the way.
A conflicted merge-back goes to the resolver. The Git view's merge button always handed a conflict to an agent and retried; the automatic approve path aborted and put the warning in the operations manager's tool result, where no person reads it — and since a branch is per member, every later approval for that member then failed the same way, for ever. The automatic path now hands the conflict to the configured merge resolver in the integration worktree and lands when it concludes; it believes the tree, not the agent. With no resolver configured, you are told once.

0.18.10

Recognise Antigravity CLI sign-in through its native read-only quota report, without restoring a workbench sign-in workflow.
Show Antigravity weekly model quotas, reset times and remaining credits in Usage using the native CLI account reports.
Cache account reports for one minute and respect the live limits preference.

0.18.9

Remove Antigravity’s workbench Sign in action and ACP login helper. Authentication-required errors now direct users to native Antigravity setup without opening a sign-in terminal.
Restore the core source layout expected by desktop and host builds.

0.18.8

Wait for the WSL interactive-shell PATH before launching the workbench host, so nvm-installed agent CLIs are found reliably.
Detect reachable LM Studio and Ollama endpoints through mirrored WSL loopback before trying the Windows gateway, and recover from stale host IPs.
Preserve Windows installer command quoting in terminals so Antigravity setup can launch the Workbench executable from a path containing spaces.

0.18.7

Show Codex remaining credits and Claude prepaid balances when the signed-in account exposes them. Show Claude monthly credit spending in dollars, including accounts without a reported monthly cap.
Keep prepaid balances separate from monthly spending caps and preserve unavailable figures instead of treating them as zero.

0.18.6

Place Claude and Codex usage cards beside each other, with smaller runtime cards stacked in a separate column. Adapt the layout to the pane's width.
Show progress while downloading and extracting the Antigravity ACP server.
Report cancellation immediately when an installer terminal closes, instead of leaving Settings waiting for a five-minute timeout.
Let awaited runtime installs finish within the desktop’s twenty-minute installer deadline before timing out the host link.

0.18.5

Replace Gemini CLI with Google Antigravity after Google retired individual Gemini CLI sign-in. Terminals launch agy; workbench agents use Google's official Antigravity ACP server, installed on the root's own target.
Preserve saved team selections and runtime enable preferences. Sign in to the ACP server from Settings using its own Google authentication flow.
Show Antigravity workbench activity in Usage and point to /usage in the native CLI for account quotas. Remove the retired Gemini OAuth quota probe.

0.18.4

Enable or disable installed runtimes from Settings. New agents, terminal choices and the Usage pane follow these preferences; existing sessions keep running.
Show usage only for enabled runtimes with their CLI and required adapter installed. Codex and Gemini now have account usage support, and Claude and Codex usage contributions expand inside their own cards.
WSL CLI and adapter installs preserve the host's Node and npm on PATH and report failed installs accurately.

0.18.3

Three defects the A-Team found and could not deploy, fixed here.

A task handed to someone else no longer points at the previous assignee's worktree (T-85). Reassigning kept worktreePath and workBranch, so the new assignee worked in the old one's worktree, committed to their branch, and approval merged that branch as if it were the new assignee's work. Those three are cleared on handover and recorded again when the new assignee starts; history and provenance are kept.
A lifecycle marker must own its line (T-76). TASK_START, TASK_DONE, TASK_BLOCKED and TASK_DELEGATE matched anywhere in a line, so "I'll output TASK_DONE:T-1 when the tests pass" moved T-1 to review. They are anchored now, and ignored inside a code fence, exactly as the verdict pair has been since 0.17.
The work signature follows content, not just which files are dirty (T-77). It hashed git status --porcelain, which prints the same line whatever is inside a file — so a revise round that re-edited a file it had already touched left the signature identical and the re-review was refused as "no changes since review". That is the common shape of addressing feedback. It now hashes the uncommitted diff and the content of untracked files as well.

0.18.2

Costs follow the machine's region. With no currency set the app read one from app.getLocale(), which is Chromium's UI language and is often en-GB on a machine nowhere near Britain — so an Australian user's spend appeared in pounds. It now reads the operating system's own locale, which carries the region, and mjuWorkbench.llm.currency still overrides it.
A paused agent no longer reads as a broken one. Everything that stops an agent landed in the same error status, so an agent waiting out a usage limit looked identical to one that needed a person. Operations now shows the cause — limit reached, sign-in needed, out of quota, CLI missing, unreachable — with what to do and, for a limit, when it resumes.
Mission Control opens on the agent you clicked. A card's button meant "show me this one" and then opened on whichever session came first.
Cards keep their place while the team map loads. The member names arrive a moment after the cards do, and in that moment no saved position matched, so every card fell back to the computed layout — which looks exactly like an auto-arrange nobody asked for.
Start one member of a running team. A crashed agent vanished from the map, and the only way back was stopping and restarting the whole team, losing everyone else's context to recover one. A member whose agent is not up now has its place on the map with a Start button for just that member.

0.18.1

A task says where it came from. A plan's own tasks carried its id, but everything the team spawned while working — follow-ups, defects, residuals — carried only a pointer to its parent. A board that began as eight planned tasks grew to sixty-seven with nothing saying what belonged to what, so none of it could be filtered or archived together. A spawned task now inherits the plan, intent and brief of the task it came from, down a chain of any depth, and records who created it.
Filter the board by plan. Pick a plan to see everything it produced, its follow-ups included, or "No plan" for work that belongs to none. With the existing select-all and bulk archive, that is how a finished piece of work leaves the board in one go.
A plan counts the work the team added. A plan's decomposition stays exactly as approved, but tasks spawned against it are now reported beside it, so a plan no longer reads "8/8 done" while fifty-nine follow-ups are open. The unify step names the open ones too.

0.18.0

Start the local model from any project. Only one host on a machine runs a model, so from every other project it could not be started at all — the instruction was to go and open the Windows project first. Setup and the Inference pane now offer to start it where it can actually run, and say which project that was. Stop and restart go the same way.
A project can have a window of its own. Each root in the project switcher has an open-in-new-window control. That window is pinned to its project: switching projects in another window leaves it alone, and asking for the same project again focuses the window that already has it rather than opening a second.

0.17.2

One task at a time per member. An agent is one conversation and takes one prompt at a time, but the board dispatched every ready task a member owned in a single sweep — twelve landed on one member at once. Each moved to in-progress and each sent a prompt, so the board showed twelve tasks being worked on while eleven sat queued behind the first, sharing its context window and never getting the fresh context a task is meant to start with. A member already on something is now held, and their next task goes out when the current one finishes or when the sweep finds them free.
A plan can finish. Only an operations run ever wrote the unify summary, so a plan whose tasks the board dispatched itself stayed at UNIFY for ever — reading as complete, because the bar was full and every task said done. Plans now says what is actually outstanding and offers to close it, deriving the summary from the board, the intent's checks and the decisions taken, exactly as a run would. Unverified acceptance criteria stay unverified and are counted as such. The team map says the same rather than showing a full bar.
Open a project in its dev container. A repository that carries a .devcontainer/devcontainer.json describes the machine it wants to be built on, and until now the app could only ignore that and run beside it. A dev container is now a target of its own, alongside this computer and a WSL distro: "Add root… → In a dev container…" picks the folder, the Dev Containers CLI builds and starts the container — image, features, postCreateCommand and all, with every line it prints shown while it works — and the workbench host, the agents it starts and the integrated terminal all run inside it. A container somebody else built, in a terminal or with a compose stack, is picked up without any of that: using one needs only Docker, and only building one needs the CLI.
The container is the container, not an approximation of it. Commands run as the container's own remoteUser, with the remoteEnv the config and its features ask for — which docker exec does not apply by itself, and which is where a feature's toolchain usually is — and with the PATH an interactive login shell there would have. A terminal tab for a container root is a shell inside it. Files open at the right place on both sides of the bind mount, and a URL an agent reports on a container port opens on the port the container publishes.
Rebuilding is expected to happen. The target is remembered against the folder rather than the container, so "Rebuild Container" in any tool leaves the project working, and the host's own state is kept in the workspace mount, which is the part of a container that survives. Docker and the CLI are found on PATH, or named in Settings → Dev containers; podman answers the same commands. Fetching the CLI with npx is offered but off, because it downloads and runs a package from the network.

0.17.1

An agent that hits its usage limit comes back by itself. A plan's allowance refills on a clock, so waiting for it is not a decision anyone should have to sit and make. The limit is recognised, the reset time is read out of whatever the provider said (an instant, a timestamp, "try again in 90 minutes", "resets at 3pm"), and the agent is restarted just after it — the board's sweep then hands it back the task it was on. With no stated reset it retries on a backoff from five minutes to an hour. Stopping the agent cancels the wait; so does its next successful turn.
You are told, once, and told what happens next. "Ben hit its usage limit. It restarts at 6:00 pm and picks its task back up." Mission Control shows the same in amber rather than red, with the reset time, because nothing is broken. Other failures — an expired sign-in, a missing CLI — notify too, with their own next step.
The failure reporting from 0.17.0 actually runs. The classifier shipped but nothing called it: an edit to the agent manager was lost, so sessions still went to error with no reason attached. Failures are recorded now, on both the start-up briefing and a failed turn.
Windows and macOS CI. The remaining red tests were about the runners, not the code: a fake filesystem keyed by POSIX paths while the analyser built Windows ones, and an electron-builder assertion written with \n against a CRLF checkout.

0.17.0

Memory enrichment actually completes. graphify runs four chunks at once by default and gives each 600 seconds. The bundled server has one slot, so three of every four chunks sat in a queue and were cancelled before they were ever read — which is why almost nothing landed. The semantic pass now runs one chunk at a time with a timeout that matches how fast a local model really generates, and a smaller answer cap so a chunk finishes rather than grinding out 8k tokens at 27 tokens a second.
Restart an agent. Mission Control has a Restart button: a fresh backend process on the same worktree, resuming the conversation. This is the fix after signing in again, and there was no way to do it short of stopping the whole team.
An agent that fails says why, and what to do. A backend failure is classified — sign-in expired, rate limited, model unavailable, CLI missing, network — and Mission Control shows the reason, the next step and the command that performs it, with a button to run it in a terminal. An expired single sign-on now reads as "not signed in ... run claude /login" instead of a silent error chip and a board that stops moving. The reason the priming failure threw is logged instead of discarded.
Cards stay where you put them. The team map keyed saved positions by the card's numeric agent id, which the host reassigns on every restart, so a position saved for one member came back attached to another and the rest jumped to the computed layout. Positions are keyed by member name now.
Costs honour the currency setting. The app resolves a display currency and fetches the rates, but nothing in the UI was reading them, so Mission Control and Operations printed whatever the agent reported (USD). They now convert; set it in Settings → Models → Currency, and ≈ marks a figure shown unconverted because no rate was available.
The local model is no longer open to anything on the machine. The bundled server is started with a bearer key, minted per install, and the workbench hands it to its own routes, the agents it starts and the hosts it shares the model with. Loopback is not a permission: any local process, and any page in a browser, could post to it before.
WSL networking can be configured from the app. WSL2 defaults to its own network, so a distro cannot reach the model the Windows side serves. Setup now reads %USERPROFILE%\.wslconfig, offers to add networkingMode=mirrored (keeping everything else in the file, with a backup), and offers the wsl --shutdown it needs as a separate, clearly labelled press.
The Inference pane shows the whole machine. A "Projects on this machine" table names every project, its target, and whether it serves the model, uses one another project serves, or cannot reach it.

0.16.18

The Copilot terminal profile runs gh copilot. The quick-launch profile typed a bare copilot, which is not on PATH on Windows when the Copilot CLI is installed through the GitHub CLI. gh copilot runs it everywhere gh is installed, on Windows and in WSL alike; a mjuWorkbench.runtimes.copilot.command setting still overrides it.
Editing a terminal profile is visible. In the new-terminal menu's "Manage profiles…", each saved profile now has a pencil beside its remove button; clicking the row still works, and the form's button reads "Save" while editing.

0.16.17

Memory's Update uses the model. Update ran graphify's own update, the free AST pass over changed code files, which never calls a model — so with the local runner configured for memory, Update finished and the Inference pane never moved. With a semantic backend configured, Update now runs an incremental extract instead: graphify caches every finished file, so only new and changed files reach the model. Without a backend it stays the code-only update.

0.16.16

"Ask the Scribe to describe it" shows what it did. The Architecture view's button quietly added another unassigned "Describe the architecture for the map" task to the board on every click and showed nothing. It now reuses the open task if there is one, opens the task board on it, and says under the button who it is queued for — or, when the project has no team member with a scribe, writer or architect role, that it is unassigned and how to get it written.

0.16.15

A failed semantic pass still leaves a graph. When the model-backed pass fails for any reason — an overflowing or unreachable server, a missing key or package, the time cap — memory now falls back to the free code-only pass, so the repository gets its graph and Setup's Index step completes. It used to fall back only on a few recognised messages; a run that failed on anything else (the context errors of the last few builds) left no graph at all, which is why Index never ticked on Windows. The note says what failed; files already enriched are kept and Update tries the rest again.
Hours for a local semantic pass, not thirty minutes. A local model works through its chunks one at a time, minutes each; the cap is now four hours for the semantic pass and stays thirty minutes for code-only.

0.16.14

One request at a time on the local model. Recent llama-server builds pick their own slot count and share one KV cache across the slots, so graphify's parallel chunks split the 32k window between them and failed mid-decode with "Context size has been exceeded" although each prompt fitted. The runner now starts with --parallel 1 (a -np of your own in Extra args wins) and memory enrichment runs one worker, so a request has the whole window. The Inference pane explains this failure as concurrency rather than "prompt too large" when the prompt fitted.
Inference tells you what happened. Recent requests now show the time (the column was blank), the workbench use for its own routes (memory enrichment, editor assist) instead of a dash, and the failure reason on a line under each failed request. The llama-server output is coloured by level — errors red, warnings amber, information dimmed — with the tokens-per-second figure picked out.

0.16.13

Memory enrichment is cut to the model's window. graphify packs files into 60k-token chunks by default and lets the model answer with up to 16k — sized for hosted models; a local server rejects any prompt over its loaded window outright, whatever that window is (0.16.12's 32k still saw a 46k prompt). The runner now tells memory the window it loaded, and the semantic pass runs with --token-budget and an output cap sized to it: ~19k-token chunks and 8k answers at 32k. The semantic pass label in the memory log says the chunk size it used.

0.16.12

WSL projects on a Windows desktop use the Windows model, full stop. A distro's host now learns it is driven by a Windows desktop and never downloads or runs a model of its own: Setup's Local model step explains that the Windows side serves it into WSL and shows the shared model's state; Set up and Start are refused with a pointer to the Windows project; the Inference pane says "served from Windows" or why it cannot be reached instead of "Stopped".
The share probe proves it reached the right server. It compares the model file both servers report on /props, so an old runner left behind on the same port inside the distro no longer passes for the Windows one — it is named in the hint instead. A host that restarts is sent the offer again.
A context window big enough for the assigned work. All three catalogue models start at 32k (they train at 32k), and the runner raises its window to what its wired uses need — memory enrichment's whole-batch prompts and the merge resolver's whole files need 32k; 16k rejected every enrichment request. A running model that is short shows the shortfall in Setup and Inference, and Restart picks up the larger window.
One clear sentence for a prompt that does not fit. "Prompt too large: ~23,181 tokens against the model's 16,384-token context. Restart the local model with a larger context …" — llama-server's own figures, once, with the fix, instead of its sentence quoted and then paraphrased. The Inference pane shows the failure on its own line with the use, model and time.
Setup installs run in the integrated terminal. A prerequisite's Install button opens a terminal tab in the pane (which comes to the front) rather than a window behind the app, and re-detects on the real exit code. On Windows, Re-detect re-reads PATH from the registry, so a tool an installer just added is found without restarting the app.

0.16.11

Inference shows the model's own numbers. llama-server now starts with --metrics, and the pane reads them: generation and prompt-eval tokens per second, KV-cache use, requests in flight and queued, lifetime tokens served, plus a collapsible tail of llama-server's output. Every request in the recent list carries its own tok/s.
Each capability says how it is configured. Memory, the merge resolver, the DLP classifier and the editor assist show their resolved backend ("Mojo Up local model (qwen3-4b)", "dedicated agent on native", "off") and, when there is nothing to show, why: the local model is not serving, the backend runs outside the proxy, the classifier is off in the policy.

0.16.10

Copilot CLI run through the GitHub CLI is found. gh copilot (gh 2.90+) downloads the Copilot CLI to the GitHub CLI's own folder rather than PATH, so the workbench reported it missing. Detection and every spawn now try, in order: the configured command, a copilot on PATH or in npm's global folder, the copy gh downloaded, and finally gh copilot -- itself, which fetches it on first use.

0.16.9

The Proxy tab is now Inference, and it shows what the workbench itself uses the local model for. Memory enrichment, the editor's inline assist and the DLP classifier each go through a traced route of their own, so the pane lists them with request counts, tokens and when they last ran, and opens to the last exchanges: the prompt that was sent and the response that came back, live as they happen. Agents' conversations are never traced this way.
Start, Stop and Restart for the bundled model, from the Inference pane.
Sharing no longer flickers. A host relaying the model it was given announced it as its own, which made the desktop offer it back and withdraw it every second; relayed announcements are no longer a source. The Setup card says "shared" when it is using another host's model.
Copilot CLI is detected on Windows. Detection asked where, whose first hit for an npm CLI is the extensionless shell shim beside copilot.cmd; it now resolves PATH with PATHEXT and looks in npm's global folder first.
Terminals are scoped to the project. Switching projects switches the terminal tabs with it; the shells keep running and come back with their project. Optional prerequisites carry a badge.

0.16.8

The Proxy panel shows the whole local stack. Beside the request counters: the local model the proxy fronts — model, endpoint, backend, layers on the GPU, and whose it is when shared from another host — every agent session going through the proxy (the native bridge, Ollama, LM Studio, hosted endpoints) with runtime, model, turns, live context occupancy and status, and the proxy's live routes.
Setup installs prerequisites. Step 1 now has an Install button per missing item that runs the right command for the machine — winget on Windows, Homebrew on macOS, apt elsewhere — in a terminal, the way a runtime is installed, and re-checks when it finishes. Copy copies the command, not a description. npm is detected correctly on Windows again (its .cmd shim could not be spawned without a shell).
Step 7 is "Integration": companion apps, starting with MojoFlow dictation.

0.16.7

One model server for every host on this machine. When a host on the Windows side serves a model — on the GPU, which a WSL distro cannot use — the desktop offers that server to the hosts inside WSL. It checks from inside each distro that the endpoint answers, then the distro's runner uses it while its own is not serving: agents, memory enrichment, guardrails and the merge resolver in WSL run against the Windows GPU. The Setup page's Local model card says whose model it is using. When the distro cannot reach the Windows loopback (WSL in NAT mode), the card says so and how to fix it: networkingMode=mirrored in .wslconfig. mjuWorkbench.localModel.share turns the sharing off.

0.16.6

The proxy runs when the bundled model does. The compatibility proxy only started when Ollama or LM Studio agents were enabled, so a desktop running the bundled llama.cpp model alone showed a Proxy panel that never came up. It now also starts when the MCP tool proxy is on or while the bundled model is serving, and the panel says what would start it.
The runner's Log button works. Instead of handing a temp file to an external editor, the Setup page shows the runner's status and llama-server's recent output inline, with Refresh.
Agents pane lists tasks. Under each running agent: the board tasks it holds, in progress or in review; click one to open the board on it.
Terminal profiles. A saved profile's tab keeps its name instead of taking the shell's title; saved profiles can be edited, not only removed; the quick-launch buttons only offer agent CLIs the host actually found.

0.16.5

Tab colours apply. Picking a colour in a terminal tab's menu did nothing: the rename field closed the menu on blur before the swatch's click landed. Blur now only saves the name.
No Terminals entry in the sidebar. The terminal is the dock's tab (Ctrl+`) and the panel it can be dragged to; the View menu entry and the navigation item that opened a second, full-page copy are gone. Pop-out windows are unchanged.

0.16.4

Drag panels between the panes. History, Terminal, Agents, Usage, Proxy, Files, Editor and the commit graph can each be dragged from the bottom dock to the right rail and back, and reordered within a pane, the way VS Code's views move between containers. The layout is remembered. The ui.historyPlacement and terminal.placement settings are retired: the history no longer has a sidebar option, and where anything lives is a drag away.
A Proxy panel in the dock. What the VS Code extension's status-bar tooltip showed: whether the local model and MCP tool proxy is up and on which port, the session's requests, tokens, tool calls, repairs and spend, the upstreams agents are routed to, and the last requests with their outcome and latency.
Terminal tab colours and your own profiles. Right-click a tab to rename it, give it one of eight colours, or kill it. Manage profiles… in the new-terminal menu saves your own: a name, the command to type into a fresh shell — claude --model opus, npm run dev — an optional folder and a colour its tabs start with (mjuWorkbench.terminal.profiles).

0.16.2

Your data moves to the new name. On first start the app renames %APPDATA%\Mojo Up AI Workbench to %APPDATA%\AI Workbench — projects, settings, paired devices and downloaded models included, instantly, since it is a rename on the same drive. Anything a fresh 0.16.0 run had written under the new name is kept beside it as AI Workbench.before-migration-… rather than deleted. This replaces 0.16.1's approach of pinning the old folder name.

0.16.1

Your data is back. 0.16.0 renamed the product, and Electron names the app's data folder after the product name, so the app started against an empty %APPDATA%\AI Workbench and looked like a fresh install — projects, settings, paired devices and downloaded models were all still in %APPDATA%\Mojo Up AI Workbench. The data folder is now pinned to that original name and will not follow the display name again. Nothing was lost; the empty folder 0.16.0 created can be deleted.
One terminal pane, not two. The terminal lives in the bottom dock or the right pane (mjuWorkbench.terminal.placement), never both; a button in the pane moves it, and Ctrl+` follows it.
Popping out takes the tab with it. A terminal or a file opened in its own window leaves the tab strip and comes back when that window closes.
Full screen. The editor and the terminal pane each have a full-screen toggle (Esc leaves) beside their pop-out button.

0.16.0

An integrated terminal. Shells run on real pseudo-terminals in the desktop app — ConPTY on Windows, forkpty elsewhere — inside the target the active root lives on: a WSL root gets a shell in its distro. The terminal is a tab in the bottom dock (Ctrl+`) and on the right rail, a Terminals view shows every shell at once, and any terminal pops out into its own window. Sessions belong to the app, not to a pane: close a pane, move it, reload, and the shell is still running with its scrollback replayed — only Kill ends it. The terminals open when you quit are offered back on the next start.
Launch an agent in a terminal. The new-terminal menu offers Claude Code, GitHub Copilot CLI, Codex, Gemini CLI, OpenCode and Cline as profiles, each started in the root's folder inside a login shell so the shell stays when the agent exits, plus a command of your own. Tabs show activity, rename on double-click, and the shell's own title.
The editor lives on the right. The built-in editor is a tab in the right pane beside Files, Terminal and the commit graph rather than an entry under Knowledge; each right-pane tab remembers its own width. A file changed on disk by an agent or another editor reloads when the buffer is clean, and offers Reload / Keep mine when it is not.
History sits in the dock by default. ui.historyPlacement now defaults to bottom.
AI Workbench. The product is named AI Workbench (by Mojo Up) in the window, the installer and the sidebar, and the executable carries a plain description.
What's contributing to your Claude usage. Under the runner cards in the usage dock, a collapsed control reads Claude Code's own session transcripts on this machine and answers the way claude /usage does: how much of the day's or week's usage was at >150k context, came from sessions active 8+ hours or from subagent-heavy sessions, and which skills and subagents were in play.
Memory graph fixes. The flat view draws again after a spell in 3D; the 3D view shows a "Laying out N nodes…" spinner until the force layout has settled; both fill the card instead of stopping short of its bottom edge.
Settings: mjuWorkbench.terminal.shell (per machine and per distro), terminal.fontSize, terminal.scrollback.

0.15.5

Routines have a page. "Routines" sits in the Work section of the sidebar, beside Tasks: the daily review's prescriptions and the routines that run them, with a line on what each is. Operations still shows both.
The Memory page opens faster. Every graph send used to run graphify's staleness check and two git probes (a second or more inside a distro) and re-parse the 10 MB graph — and three views asked at once when the page opened. The status answer is now reused for fifteen seconds (dropped at once when anything changes), the parsed graph is reused while the file is unchanged, and concurrent requests share one send.
The 3D scene is lighter. Bloom renders at half resolution, the pixel ratio is capped at 1.5 on high-density displays, particles only flow on graphs of up to 250 nodes, and the renderer asks for the high-performance GPU without antialiasing — the same look at a fraction of the fragments on an ultrawide.

0.15.4

Browser profiles live where you can write. A named browser's profile folder now defaults to %LOCALAPPDATA%\mju-browser\profiles-<name> on Windows (~/.mju-browser/profiles-<name> elsewhere) instead of the root of the system drive, which most accounts cannot create folders in. The first time the app resolves an instance with no ~/.mju-browser/config.json, it writes that root into the file, so the mju-browser CLI on the same machine means the same folders. A root already pinned in the config still wins.
Instances survive a restart. The names of browsers launched here are remembered in the app's user data, so they are listed (stopped) after the app restarts instead of vanishing and orphaning their profile folders.
Remove an instance. Browser → instance menu → Manage instances… lists every named browser with its state and profile path; Stop closes it, Remove stops it, deletes the profile folder (sign-ins and all) and forgets the name, after a confirmation.
The project switcher's shared-root note now says what it means: "same folder is a root in Testing", with an explanation on hover.

0.15.3

Setup starts with the machine. A Prerequisites step before Runtimes: Node (and whether it is new enough), npm, git, the GitHub CLI, Python and uv, WSL on Windows — each found or not, what it is for, and the command that installs it, with Copy.
Installed is not signed in. Every runtime row now says both: whether the CLI is there and whether it is signed in to its provider — read from where each keeps its credential (the GitHub CLI's login for Copilot, Claude Code's stored OAuth and plan, Codex's auth file or an OpenAI key, Gemini's Google login or key, OpenCode's providers). A "Sign in" button opens the CLI's own login in a terminal. Settings → Runtimes shows the same.
Installs on Windows report back. "The terminal could not report completion" is gone: an install now runs inside a small script that records its exit code, the workbench waits for it, then re-detects — so the row says "ready" or why not. Detection also looks in npm's global bin folder (and the usual install locations) even when PATH has not caught up, which is why a just-installed CLI showed as "not found".
Projects and roots, told apart. The switcher labels projects and roots, counts a project's roots, marks a root that another project also holds ("also in Testing"), grows a filter past eight roots, and opens "Manage projects…": rename inline, remove a root, delete a project (the repositories on disk are untouched).
Back up and restore settings. Settings → Projects & Editors → Back up & restore writes the global and per-target layers plus a description of each project to one JSON file, and reads it back — adding what is missing, or replacing this machine's layers.
Defaults that prefer local. The memory engine's semantic pass picks the local model runner when it is up, before any API key in the environment. With the watcher keeping the graph current, the Memory page no longer shows git hooks and merge driver as things to install; they appear only when hooks are the chosen automation or are already there.

0.15.2

The graph in three dimensions. The Memory page and the brain now draw the same scene Agentic OS does: lit spheres coloured by community (or type), sized by connectivity, halos pulsing on the god nodes, extracted links teal with particles flowing along them, inferred ones fainter and violet, all in fog before a starfield under a soft bloom, turning slowly until you take hold of it. Communities are pulled to regions of a sphere so they read as bodies of knowledge. Hover dims everything a node is not connected to; click flies to it and holds it. Full or Core density, Pause/Play. The flat canvas stays as a Layout option and as the fallback where there is no WebGL.
The brain, properly. Corner chrome over a full-screen graph: fly-to search top-left; community layer pills, layout, the memory list toggle and Exit top-right; the memory list as a glass rail; and a console along the bottom that asks the graph — the answer's cited nodes light up and the camera flies to them. Clicking a node raises its note over the graph: type, community, source and the lines it was read from, with Copy and "ask about this". Esc closes the note, then leaves.
Delete a plan. Plans has a Delete beside Abandon for anything not mid-dispatch; a draft whose run is parked is abandoned first so the run ends cleanly.

0.15.1

The memory graph, your way. A Layout panel on the Memory page: force, radial-by-community or a grid of communities; lite or full density; size by connections or uniform; colour by community or by type; labels auto, all or none; spacing and repulsion sliders. Remembered per user. Search now flies the view to the best match (Enter), with a list of candidates as you type.
Enter the brain. The same graph full-screen: layer chips to show or hide communities, fly-to search, the layout panel, and a note for the selected node — its type, community, the lines it was read from (copyable) and what it connects to. Esc leaves.
Recent activity. Which source files were touched this week, which have changed since the graph was built (what the next update re-reads), and which the graph cites but are gone. Click a file to fly to its nodes.
Knowledge explorer. Walk the graph: communities (largest first, with their type mix) → the nodes in one (best-connected first) → one node, with its source excerpt and connections. The canvas follows every step.
Memory across workspaces. In the desktop app a third mode lists every open workspace's graph — nodes, edges, communities, stale files, engine, last update — with the totals, from each running host (memory.status over the Control API).

0.15.0

Operations knows which numbers are whose. A switch at the top of the page: This project is this root's ledger, agents, board and memory; All workspaces is every open workspace at once, merged by the desktop from each host's ledger, with a per-workspace table and "n of m reporting". The same strip in either scope — spend, requests, tokens over the chosen range, each with today's share and a day-by-day sparkline — so a figure is never read as the other kind by accident.
The daily review. A routine (or a button) has the facilitator read the day — spend by runtime and model, quota headroom, agents and sessions, the task board, memory freshness, what people kept asking for — and write back at most four prescriptions, each with the evidence it rests on and a next step. They sit in Operations until you take one up, mark it done or skip it; a skipped finding stays away for a month, and one nobody acted on comes back older. Stored under .mojoup/reviews/, also over the Control API (reviews.latest, reviews.run, reviews.setStatus).
Routines are where you look for them. The routines card sits under the strip, beside the review, with "Run the daily review" as an action.
Every Claude window, by name. Anthropic now describes each limit with the model it is scoped to, so the Usage tab shows "Week · Fable" with its own percentage and reset beside the account-wide five-hour and weekly windows — and a family added tomorrow appears without a code change. Dollar-capped windows show in dollars.
Copilot credits, the way VS Code shows them. The Usage tab reads the same endpoint VS Code's Copilot card does: plan (Enterprise, Business, Pro, Free), credits used of the monthly allowance and when it resets — "181.9 / 25,000". The GitHub CLI's login is picked up on its own; a token can be stored for a machine without gh. The billing-platform token and username are gone.
Shape it first. A Team Work conversation can open with a brief instead of a plan: turn on "Shape first" beside the team picker and the operations manager coaches you through the piece of work the way the SEED framework does — it proposes a project type (application, workflow, client site, utility or campaign), walks that type's sections one or two at a time, records what you settle, takes product choices as decisions so they are never asked again, and writes the phase breakdown as it emerges (what is built, what is testable, the outcome). A brief panel above the composer shows the type, section-by-section progress, the phases and the quality gate; when the gate passes, "Launch phase 1" starts a run that plans only that phase and re-asks nothing the brief answered. Shaping is turn by turn, so a brief can take a week and never holds the team.
Plans follow PAUL's loop: Plan → Apply → Unify. A plan now states its acceptance criteria first (Given / When / Then, each with how it will be verified), every task names its files, a verify step and the criteria it satisfies, and the plan carries boundaries — what must not change and what is out of scope. The criteria become the run's success checks, so the outcome contract is no longer a second prompt. A draft plan parks the run until you approve or abandon it in Plans (no timer; nothing is dispatched behind your back), and a run that ends writes a unify summary: what shipped against what was planned, deviations, decisions made along the way, deferred work and the one next action.
Honest apply signals. A worker that finishes with doubts says so — "done with concerns" and what the doubt is — and the reviewer reads those first; a reviewer sending work back says whether it is a gap (something asked for is missing) or a drift (something different was built).
Plans shows where the loop is. A PLAN ▶ APPLY ▶ UNIFY stepper in the header, the brief and phase the plan came from, a progress bar, an acceptance strip with each criterion's status (pass or fail one yourself), collapsible boundaries, and the unify card once the run is reconciled. Nodes show their files, the criteria they deliver, and any concerns or gap/drift verdicts. The view refreshes when a plan or brief changes, not only when a task moves.
The Team map's Plan card shows the loop position as three segments with the current one live, a progress bar, the phase of its brief and the acceptance count.
A worker that cannot finish asks instead of guessing. task_done with needs_context parks the task on a blocking question to you; the run keeps waiting (it is not a stall, and the stall timer holds off) and your answer re-dispatches the task with the missing information. The same holds for any task parked on a question: the run stays alive to see the answer.
Diagnose before patching. When a task hits the review cap or the dispatch cap, the run asks where the problem is — intent, spec or code — the way PAUL routes a failure. A code problem retries the task with fresh review rounds; a spec or intent problem stays parked with the reason on the task, is recorded on the run, and the run's closing note says what to fix.
Your own SEED types. Drop a JSON file in .mojoup/seed-types/ (id, label, rigor, demeanor, sections with explore / suggest / required) and the coach offers it beside the built-in five; a file that does not validate is logged and skipped, never fatal.
New setting mjuWorkbench.ops.shapeByDefault (repository-allowed): new Team Work conversations start with "Shape first" on until you touch the toggle.
Plans that reached their goal are marked verified again: the match ran on a status auto-dispatched plans never reach, so it found nothing.
Control API: briefs.list and briefs.get (read-only).

0.14.22

Runtime usage in the dock. A Usage tab beside Agents, with a card per runner. Claude Code shows the account's real five-hour and weekly windows with the time they reset — read from the credential Claude Code already stores, the same numbers its own /usage prints — and an OpenRouter key shows its balance. Everything else shows what the workbench itself metered: requests, tokens and cost today.
Every card says whether its numbers are live (the provider's) or metered (ours). A provider that will not answer loses its bars, never its spend, and the card says why in words.
Copilot's quota is premium requests, which GitHub reports through its billing platform rather than through the Copilot CLI's credential — "Mojo Up: Set GitHub Token for Copilot Usage" stores a token that can read it. Until then Copilot shows metered spend, like any other runner.
usage.liveLimits turns provider requests off entirely.

0.14.21

A commit you opened can be closed again — a close button on the panel, pressing the same commit a second time, or Escape. It used to open and stay open, taking a third of the pane with no way out.
The branch filter was hiding most of your branches. Any ref with a slash in it was taken for a remote, so feat/desktop-app and every mojoup/a-team/… branch were left out and the list came down to main — while the graph showed you standing on one of the branches it omitted. The log is read with full ref names now, so a branch is a branch however it is spelled.
Launching a real browser works. Chromium's launcher hands the command line to the browser process and exits straight away — Edge does it every time — and the workbench was reading that as a crash: "msedge.exe exited with code 0 before it was ready", while Edge was opening perfectly well in front of you. A zero exit is now a hand-off and the launch waits for the debugging port; only a real, non-zero exit is a failure, and a browser that never opens its port says what to try instead of just timing out.

0.14.20

The browser's menus were behind the web page. A tab is a native view the app paints above everything the interface draws, so the instance menu and the New-instance form opened underneath whatever page was loaded — the item was there, the form was there, and neither could be seen or pressed. The page now steps aside while a menu, the form or the downloads list is open, and comes back when it closes; tooltips point upward into the chrome.
The branch filter above the commit graph is full width again. A spacer beside it was claiming half the row, which is why "All branches" wrapped onto two lines in the sidebar.

0.14.19

"New instance…" is back in the browser's instance menu. It was written as a second React Aria section beside the instance list, and two sibling sections without keys collapse into one — so the only way to launch a real browser was missing from the menu that offers it. The menu is one flat list now, and the smoke run opens it and reads back what is in it, so a menu cannot quietly lose half its items again.

0.14.18

The browser's instance picker is an icon, not a wide select, and choosing "New instance…" now opens a small form with a heading, a labelled Name field and a Launch button — instead of a bare box in the tab strip that looked exactly like an address bar. Typing a URL into it says so in words rather than failing with the rule it broke, and Launch stays disabled until the name is one the app will accept.
The branch filter above the commit graph has room above and below it, and on the Git page it no longer stretches the width of the window; the commit count sits beside it.
The version in the collapsed rail is centred. It was pushed right by a utility class and, being wider than a 48px rail, hung off the left edge.

0.14.17

You can see who is in the browser. When an agent drives a tab, the tab shows a pulsing dot with the agent's name, and a bar under the address bar names the agent and its team while it works. It fades ten seconds after the last action.
DevTools, per tab, from the bug icon — in a window of its own, since the tab is embedded. For a real browser instance, press F12 in its window.
Downloads work, and go where a browser's do: your Downloads folder, with a name that never overwrites what is there. The download icon lists them with progress, and reveals one in the file manager.

0.14.16

Real browsers, by name. Alongside the app's own tabs, agents can now launch and drive a real installed browser — Edge or Chrome — as a named instance (main, sponsor) with its own profile, which is where your sign-ins live. Sign in once and the automation keeps the session. Same tools as the embedded browser (browser_launch, browser_open with an instance, then snapshot, click, type…); tabs you open in that browser's window show up in the workbench too. Identity follows mju-browser exactly — the same name means the same profile and port from the CLI and from here, and ~/.mju-browser/config.json pins either.
The commit graph is on the Git page as well, with author, hash and date.
The browser dialog has an instance switcher and launches a new instance by name; a real browser is never closed when the app quits — it is yours.

0.14.15

The browser's "+" opens a tab again. The dialog overlaps the window's title bar, whose drag region was swallowing clicks on the tab strip — a press on "+" (or the expand and close buttons) started a window drag instead. The dialog now opts out of the drag region, as the title bar's own controls do.

0.14.14

Browser tabs follow the live window. A tab's view is attached to whichever main window exists when it is shown, not to the one that existed when the browser started, and every placement is logged (position, size, zoom, window size) so a tab that paints nowhere can be diagnosed from the log rather than guessed at.

0.14.13

A browser your agents can use. The globe on the right rail opens a tabbed browser — real Chromium, in the app — where an agent can open the app it is building, run a UI test, read a page or do an automation. Agents see the page as an accessibility tree with a ref on every interactive element and act by ref (browser_snapshot, browser_click, browser_type, browser_screenshot, browser_console, browser_evaluate and the rest), the way Playwright's tools work, so they already know how. Logins persist between sessions in the browser's own profile.
What it refuses on your behalf: anything but http(s) — no file: — every permission prompt (camera, microphone, location, notifications), and downloads. Every action an agent takes is audited under its name; typed text is recorded as a length, never as text.

0.14.12

Compare said nothing when there was nothing to say. It rendered two identical panes for an unchanged file, which reads as a bug rather than as an answer. It now says "No differences", and you choose what to compare against: the last commit, or the file on disk (your unsaved edits).
Markdown preview, and a split view with the editor beside it.
The editor toolbar is icons now, the way an editor's is: save, preview, split, compare, open in a new window, open in your external editor.
Pop a file out into its own window.
The file tree is colour-coded by type — TypeScript blue, JavaScript yellow, configs purple, images, archives, locks and shells each their own — with landmark folders tinted and everything else left quiet.
The explorer's external-editor button opens the project, not whatever was selected. Opening a folder opens it as a folder.

0.14.11

Opening a folder in the file tree broke the tree. An unopened folder carries a placeholder child so it still shows a chevron; when its real contents arrived they took that child's place, and React Aria refuses an item whose id changes underneath it — "Cannot change the id of an item", and the panel stopped rendering. The children are keyed by their own id now, so a folder's contents replace the placeholder cleanly.
The drag grip is gone from the file rows: the row itself is the handle, and a narrow tree has no room for a column of them.

0.14.10

The editor writes with you. Inline suggestions as you type, accepted with Tab. They come from the bundled local model when it is running, so by default this costs nothing and leaves the machine never; Settings → … editor.inlineCompletion can turn it off, or allow your configured chat model to answer instead.
Compare. Put the file side by side with its committed version without leaving the editor.
Open in your external editor from the file pane and from the editor's toolbar — the built-in one is a convenience, not a cage.
The attributions were missing the half that matters. pixel-agents, Graphify, llama.cpp, Qwen, LiteLLM and the Copilot LLM Proxy are credited in the README and in past release notes but were nowhere in the app. Settings → Attributions now leads with them, and a test fails if the README credits something the app does not.

0.14.9

A code editor, built in. Open a file from the explorer and it opens here, in Monaco — the editor VS Code is built on — with syntax highlighting for everything a project usually contains, tabs, a dirty mark and Ctrl+S to save. It loads only when you first open a file, so a window that never does never pays for it.
Copy, cut and paste in the explorer, with the keys you expect, plus "Copy path". Pasting beside the original names it README copy.md rather than asking, and never overwrites what is already there.
The right-click menu is a third the size it was and says which keys do what.
Attributions. A page in Settings naming every open-source dependency this app is built on, its version and its licence — generated from what is actually installed, so it cannot go quietly out of date. Monaco is MIT-licensed, © Microsoft Corporation.

0.14.8

A file explorer in the right sidebar. The project's files as a tree you can work in: create, rename, move, delete, open in your editor, reveal in the file manager, and download a copy to this machine — which works even when the project lives inside a WSL distro, because the bytes travel rather than the path. Drag a row onto a folder to move it; drag files in from the desktop to add them.
A commit graph, beside it. Branches as coloured lanes with their refs, HEAD marked, paged a few hundred commits at a time, filterable by branch. Pick a commit for its files, pick a file for its diff — in the same diff viewer the rest of the app uses.
The right sidebar itself. An icon rail that is always there, one panel open beside it, dragged as wide as you like and remembered. The session history joins it as a tab when you keep it on that edge.
Nothing the explorer does escapes the project: every path is resolved through symlinks and .. before it is used, and .git/ and the workbench's own state are refused outright.

0.14.7

Being watched is a badge now, not a banner. A bar across the whole window was more than it needed to be for something you often asked for yourself. The badge sits in the title bar, is still always there while anyone is attached, and still cannot be dismissed — what it drops is the shouting.
It answers the question that follows. Press it and it names each client as it was named when you paired it, whether it can click and type or only watch, how long it has been attached, how many inputs it has sent and the last thing it did, in words. Revoking is one press away.

0.14.6

Back, forward and search, next to the menu. The title bar carries the three buttons you reach for without thinking: search your history, and step back and forward through the places this window has been — a view, and the conversation that was open in it, since Chat with two different sessions is two different places. Alt+Left and Alt+Right walk them, Ctrl+K opens search (⌘[ , ⌘] and ⌘K on macOS).
A Go menu. Back, Forward and Search History, where the desktop apps beside this one keep them — between View and Agents.

0.14.5

The window is ours now. On Windows and Linux the app is frameless: one title bar carries the menu button, the project you are in, whether its host is up, how many agents are working and what today has cost, with the minimise / maximise / close controls at its end. macOS keeps its traffic lights and its menu bar, inset into the same bar.
One menu, six sections. File, Edit, View, Agents, Window and Help open from the button at the top left, with their shortcuts written the way each platform writes them. The native macOS menu and this one are built from the same list, so they cannot say different things.
A dock along the bottom. Its tabs are always on screen — Agents, and History when you keep your sessions there — over a pane you can collapse, resize and have remembered. Ctrl+J opens and closes it.
The history placement setting worked only by accident. The first settings snapshot can reach the renderer before the shell mounts, and the shell was only listening from mount, so a window set to keep its history in a bottom or right-hand pane quietly kept it in the sidebar.

0.14.4

The workspace map works like a graph. Every memory node is now something you can point at: press one and it lights its neighbourhood, draws its edges, names what it touches and pushes the rest of the graph back. Its details open beside the map rather than over it, listing every connection with the relation that made it, and pressing one walks you there.
The map moves. Its clock was never advanced, so every spin, breath and pulse in the painter evaluated at zero and the picture sat perfectly still.
What you click is what you see. The pointer tested unrotated positions while the painter drew rotated ones, so the rings drifted away from their own hit targets as they turned. Both now read the same geometry, and memory nodes are tested at all — they were decoration before.

0.14.3

Node details were unreadable. The window meant to be opaque had no background at all: only the last layer of a CSS background may be a colour, and the pinned surface was named mid-list, so the browser threw the whole declaration away and the rotating map showed straight through the text.

0.14.2

The workspace map paints when you come back to it. The canvas only drew inside an animation frame, which the browser suspends while the window is hidden or covered, so the map could be blank while the page around it was not. It now draws on setup and again on focus, on becoming visible and on resize.
Applications carry icons, not initials. A connector is a plug, a plugin a puzzle piece, a built-in tool four cells, a machine a screen. Two letters told you nothing.
Community names are readable. A real graph has hundreds of communities and naming every one smeared them into a grey block. The biggest name in each sector is drawn, never two on top of each other, and the ring titles sit above the memory sweeps instead of under them.
The workspace map read the wrong field and showed nothing where a graph was present.

0.14.1

The workspace map reads like a knowledge graph. Memory is drawn as dense dotted arcs — every node a dot, grouped by community into thick coloured sweeps — rather than a handful of dots on a circle. Everything glows, applications are chips rather than dots, and the palette is brighter.
Search, over the middle of the map, with a match count. Matches glow; everything else recedes rather than disappearing.
Pressing a node opens its details in a Mission Control window: what it is, whether it is active, where it lives, and a button to open the file.

0.14.0

The workspace as rings. Memory has a Workspace mode showing what this agent actually has — Applications, Routines, Memory, Skills — as concentric rings around the instruction file at the centre. Connectors are in it: an MCP server is how an agent reaches outside the repository. Switch between this project and everything on the machine.
Routines. A saved operation no longer has to be a schedule. Give it a name and, if you want it automated, a schedule; leave the schedule empty and it waits until you press Run. Operations → Routines.
Settings say which machine they mean. The per-target layer named itself "This machine", which is ambiguous on Windows when the root lives inside WSL and noise on Linux or macOS. It now names the target: the distro, or "This computer".
CLIs installed with nvm are visible to the host again, so a globally installed Claude ACP adapter or Copilot CLI is no longer reported missing.
The memory settings no longer imply git hooks are installed when the file watcher is doing the work, and the VS Code wording that outlived the extension is gone.

0.13.7

CLIs installed with nvm are visible again. The workbench host ran with a PATH that had no nvm in it, so a globally installed Claude ACP adapter or Copilot CLI was reported missing and the adapter fell back to npx on every start. The WSL target now resolves the PATH an interactive shell has.

0.13.6

Routines. A saved operation no longer has to be a schedule. Give it a name and, if you want it automated, a schedule; leave the schedule empty and it waits until you press Run. Operations → Routines.
The graphify skill is a router: its 714-line SKILL.md is now 101 lines plus a build runbook, so an agent reads only the part the task needs.

0.13.5

Updates stop leaving a desktop shortcut behind each time. The installer deleted the shortcut and made a new one on every update, and on a Desktop redirected into OneDrive that delete-and-recreate leaves a safeBackup copy each time — ten installs, ten shortcuts. It now keeps the shortcut it finds. The install directory is no longer selectable, which is what allowed the delete in the first place; installs stay per-user under %LOCALAPPDATA%\Programs.

0.13.4

"Install and restart" restarts. A silent install skips the installer's finish page, which is the only thing runAfterFinish drives, so the app was replaced and never relaunched; it now passes the silent equivalent. The installer also ran before the app had finished quitting, which left it replacing the executable of a still-running app — it now launches as the app exits.
Remote clicks land in the right place when the mirrored frame is scaled down.

0.13.3

The LAN listener can actually be configured. Turning it on failed asking for a TLS certificate or explicit plain HTTP — four settings the desktop had nowhere to set. The card now has the interface, port, a plain-HTTP switch and the certificate paths, and says whether you are on loopback (where plain HTTP is fine, and which a WSL distro cannot reach) or on a real interface.

0.13.2

Remote control works on the desktop. Pair a device, Connect to relay and Open settings all did nothing: they ran host commands, and on the desktop the hosts leave the transports to the gateway, so pairing asked something that never has them. The card now reaches the gateway, turns Local IPC and the LAN listener on with a switch, and pairs inline with the token in front of you — including a Screen mirror preset. The relay is still not wired on the desktop and now says so rather than offering a dead button.

0.13.1

The Update source placeholder showed doubled backslashes (C:\\builds): a JSX attribute string is literal, not a JavaScript string, so the escaping was being displayed rather than applied.

0.13.0

Watch this window from another machine. For debugging a running instance: a paired client with the ui:view scope can see the window over the Control API, and with ui:control and the machine's separate consent, click and type in it. Off by default, both halves separately. While anyone is watching, the window says so in a bar that cannot be dismissed, and the existing kill switch cuts it. tools/remote-client/mirror.html is a viewer you can open anywhere.
Update from your own source. Point the updater at a folder holding your installers with a latest.json beside them, or at a URL serving the same document, and test a build before publishing it. Signature checking stays on; updates.allowUnsigned is the deliberate way past it for your own unsigned builds, and every install it permits is logged.

0.12.1

A model download no longer drowns the rest of the app. Progress was reported on every chunk, and each report became a frame on the link the whole workbench shares — about 35,000 of them for a 2.3 GB model. During a first-run download that swamped the channel, and Teams, Memory, templates and some buttons came up empty or did nothing. Progress now updates a few times a second instead.
Teams start again when the ACP adapter is not installed globally. Restoring a team reached for claude-agent-acp on PATH before detection had run and failed with ENOENT; it now waits for detection and falls back to npx, which is what the rest of the app already did.

0.12.0

Settings you can find things in. Preferences was one page holding twenty-nine groups of settings, so finding one meant scrolling past all the others. Settings is now a grouped set of short pages — General, Projects & Editors, Models, Behaviour, Memory, Spend, Security, Integrations — and search works across all of them: look for "ollama" from any page and it points you at the one that has it.
Settings look like settings. Related settings share a card with hairlines between rows, instead of every single row being its own floating panel. A choice of two or three is a segmented control you can read without opening it, numbers have steppers, and Overview lists every page and customisation as a row you press.
A light mode that isn't washed out. The translucent surfaces were tuned for the dark, so in light mode cards, the chat composer, the prompt suggestions and the task board columns all sat on the page at almost exactly the page's own colour. Surfaces, hairlines and shadows now change with the colour mode, and grey body text is legible in both themes.
The version number is readable again in a collapsed sidebar, where it used to truncate to "v1…".
"Design system" in Settings → Appearance is now called Workbench theme.

0.11.0

First release as a standalone desktop app. Fixes: The VS Code extension remains available as a thin bridge for this release.

Desktop app. The workbench is now its own Windows, Linux and macOS application (Electron) instead of a VS Code panel: a full window for the office, task board, chat, plans, docs and git, a tray icon, close-to-tray and start-at-login.
Projects. Group several repositories or folders into a project. Settings layer as defaults → global → per machine → project → repository (.mojoup/settings.json), and your VS Code mjuWorkbench.* settings are imported on first run.
WSL. On Windows, add a root that lives inside a WSL distro. The workbench host runs inside the distro, so git, agents and MCP servers see the real filesystem, while the window stays a native app.
Any editor. Files open in the editor you choose (VS Code, Cursor, JetBrains, Zed, Neovim or the system default).
Scheduled runs. Team starts, facilitator prompts and ops reviews on a timetable, without a window open.
Signed installer with in-app update checks against the Mojo Up customer portal.
The session history can move. The Chat / Research / Team Work switch and the list under it live in the sidebar, along the bottom of the window, or down the right-hand side. Settings → Appearance → Session history. The bottom and side panes collapse to a rail and come back.
The instruction boxes grow with what you type. Delegation guidance, review guidance and a member's agent instructions were pinned at two or three lines, so editing a page of text meant scrolling a letterbox. They fit their content now, up to a limit, and only then scroll.
Delegation and review guidance are named, collapsible sections, like the agent instructions above them. Two unlabelled boxes stacked together were impossible to tell apart once they had content in them; each now has a title and, when folded, its first line.
The model picker stays inside the member card. A long model name pushed the Refresh button out of the card, because a dropdown will not shrink below its widest option unless it is told it may.
One local model, shared. MojoFlow can reuse the model the workbench is already serving instead of loading a second copy of its own: a new localModel.status method reports the endpoint, model, context length and acceleration, a localModel.changed event follows it, and the desktop says whether a companion on this machine can actually reach it, on the announcement as well as on the reply, because that is the moment a companion switches.
A restart with agents running is quiet again. Bringing several agents back at once turned one stumble into a wall of red before the window had settled. Problems during a restore are now collected and reported once, with the summary of what came back. Three other things that looked like failures and were not: a browser notice from any panel that measures itself was logged as "the webview crashed", an agent narrating its start-up was logged as a warning on every line, and the update check warned on every start that there is no published release yet.
The Install buttons for agent runtimes now work outside VS Code — they opened a VS Code terminal, so in the desktop app they did nothing at all. The installer now runs where the agent will run, including inside a WSL distro.
The Plans session link no longer repeats the session picker's label beside it.
Team templates review their own work. Only one of the five carried review guidance, so the rest reviewed against nothing but the reviewer's taste. Every template now starts with guidance that reviews against the task's acceptance criteria, asks for evidence rather than assertion, and requires a rejection to say what would make it pass. Git isolation was already on: every member who writes gets its own worktree, and the operations manager, who never implements, stays on your checkout.
Editing a team member saves. Two settings were dropped every time you pressed Save, silently: a member's isolated worktree and its hosted provider. Unticking the worktree, or picking OpenRouter for a member, sprang straight back. Worse, saving any team took the worktree setting off its operations manager, which is the one member meant not to have one.
A team saved into a repository with no teams yet appears immediately instead of after a restart. The file watcher adopted the newly created folder but swallowed what was already written into it.
The New from template dropdown is the height of the toolbar again instead of clipping its own text, and it no longer stretches to the width of the longest team in the list.
Install for an agent runtime works inside a WSL distro whose Node is too old. Ubuntu 24.04 ships Node 18, which cannot parse a current adapter, so the install ended in a syntax error from Node's internals. Agents now run on the Node the workbench provisioned, and an adapter that still fails says why.
In the cards view, an agent past the third no longer appears to be working in another agent's worktree. Its worktree node was drawn exactly on top of the first agent's, so the hidden node's line looked like it belonged to the visible one.
The Git view reads left to right, worktree to integration to base, so the connections meet the sides of the nodes you would expect instead of doubling back across the canvas.
The minimap shows the graph on all four canvases — team map, Git, Plans and Architecture — instead of an empty rectangle, and the Architecture map has one in every layout rather than only one of them.
The line from the plan to the task board joins the two cards instead of disappearing behind one of them and leaving a stub out of each side.
The MojoFlow dictation card in the desktop app shows what is actually happening. It read the workbench host's view, and in the desktop app the endpoint belongs to the app itself, so the card said "MojoFlow not found · endpoint off" no matter how dictation was set up, and Turn on looked like it did nothing.

0.90.22Copy Anchor Link

0.90.21Copy Anchor Link

0.90.20Copy Anchor Link

0.90.19Copy Anchor Link

0.90.18Copy Anchor Link

0.90.17Copy Anchor Link

0.90.16Copy Anchor Link

0.90.15Copy Anchor Link

0.90.14Copy Anchor Link

0.90.13Copy Anchor Link

0.90.12Copy Anchor Link

0.90.11Copy Anchor Link

0.90.10Copy Anchor Link

0.90.9Copy Anchor Link

0.90.8Copy Anchor Link

0.90.7Copy Anchor Link

0.90.6Copy Anchor Link

0.90.5Copy Anchor Link

0.90.3Copy Anchor Link

0.90.2Copy Anchor Link

0.90.1Copy Anchor Link

0.90.0Copy Anchor Link

0.89.31Copy Anchor Link

0.89.30Copy Anchor Link

0.89.29Copy Anchor Link

0.89.28Copy Anchor Link

0.89.27Copy Anchor Link

0.89.26Copy Anchor Link

0.89.25Copy Anchor Link

0.89.24Copy Anchor Link

0.89.23Copy Anchor Link

0.89.22Copy Anchor Link

0.89.21Copy Anchor Link

0.89.20Copy Anchor Link

0.89.19Copy Anchor Link

0.89.18Copy Anchor Link

0.89.17Copy Anchor Link

0.89.16Copy Anchor Link

0.89.15Copy Anchor Link

0.89.14Copy Anchor Link

0.89.13Copy Anchor Link

0.89.12Copy Anchor Link

0.89.11Copy Anchor Link

0.89.10Copy Anchor Link

0.89.9Copy Anchor Link

0.89.8Copy Anchor Link

0.89.7Copy Anchor Link

0.89.6Copy Anchor Link

0.89.5Copy Anchor Link

0.89.4Copy Anchor Link

0.89.3Copy Anchor Link

0.89.2Copy Anchor Link

0.89.1Copy Anchor Link

0.89.0Copy Anchor Link

0.88.5Copy Anchor Link

0.88.4Copy Anchor Link

0.88.3Copy Anchor Link

0.88.2Copy Anchor Link

0.88.1Copy Anchor Link

0.88.0Copy Anchor Link

0.87.4Copy Anchor Link

0.87.3Copy Anchor Link

0.87.2Copy Anchor Link

0.87.1Copy Anchor Link

0.87.0Copy Anchor Link

0.86.1Copy Anchor Link

0.86.0Copy Anchor Link

0.85.0Copy Anchor Link

0.84.0Copy Anchor Link

0.83.0Copy Anchor Link

0.82.0Copy Anchor Link

0.81.0Copy Anchor Link

0.80.0Copy Anchor Link

0.79.1Copy Anchor Link

0.79.0Copy Anchor Link

0.78.0Copy Anchor Link

0.77.0Copy Anchor Link

0.76.0Copy Anchor Link

0.75.0Copy Anchor Link

0.74.0Copy Anchor Link

0.90.22

0.90.21

0.90.20

0.90.19

0.90.18

0.90.17

0.90.16

0.90.15

0.90.14

0.90.13

0.90.12

0.90.11

0.90.10

0.90.9

0.90.8

0.90.7

0.90.6

0.90.5

0.90.3

0.90.2

0.90.1

0.90.0

0.89.31

0.89.30

0.89.29

0.89.28

0.89.27

0.89.26

0.89.25

0.89.24

0.89.23

0.89.22

0.89.21

0.89.20

0.89.19

0.89.18

0.89.17

0.89.16

0.89.15

0.89.14

0.89.13

0.89.12

0.89.11

0.89.10

0.89.9

0.89.8

0.89.7

0.89.6

0.89.5

0.89.4

0.89.3

0.89.2

0.89.1

0.89.0

0.88.5

0.88.4

0.88.3

0.88.2

0.88.1

0.88.0

0.87.4

0.87.3

0.87.2

0.87.1

0.87.0

0.86.1

0.86.0

0.85.0

0.84.0

0.83.0

0.82.0

0.81.0

0.80.0

0.79.1

0.79.0

0.78.0

0.77.0

0.76.0

0.75.0

0.74.0