What's shipping in Station and Server.

Codex at full parity with Claude Code, on macOS, Linux and Windows.

• Codex runs on all three platforms, side by side with Claude Code on the same board. Each engineer works in the agent they are fastest in, for writing code and for reviewing it.
• A Codex-only machine is a full citizen: it needs nothing about Claude enabled to be usable, and the permissions a Codex session needs are approved in a guided step rather than configured by hand.
• Station runs on macOS, Linux and Windows, so every engineer can put their own machine to work, whatever they run.
• Each Station tells the board which tools it can actually run, and keeps that current as the machine changes. Work is only ever sent somewhere it can succeed.
• Every run leaves durable evidence behind — including the runs that were rejected — so you can always read what an agent actually did.
• Sessions clean up after themselves: finished worktrees are removed, branches stay tidy, and an agent’s work is never deleted along with its workspace.

Station can check the knowledge base against the code, on a timer.

• A pass takes entries nobody has checked, opens the files each one names, and records whether the claim holds. That work needs a checkout, which is why it belongs here rather than on the server.
• Off by default, per project. The control states what a run costs before you change it: one Claude session against that checkout, billed to your own account, up to 30 entries per run at the defaults.
• A pass reads and reports. It cannot edit your code, commit, or push, and it holds no privilege an operator does not.
• A verdict names the exact commit it was read at, so the check expires by itself when the code moves past it.
• A checkout that is mid-work is not disturbed. The pass runs in its own worktree, and records that worktree’s commit.

The Download button opens the download page.

• It opened the installer endpoint directly, which showed a raw error page whenever that endpoint was unhappy, and a sign-in failure rather than a sign-in prompt once those endpoints began requiring an account.
• The download page can authenticate, and offers every platform’s installer rather than guessing which one you want.
• Requires Server 3.10.0 or later on the instance you are connected to.

The reviewer can run the checks your repository already declares.

• Every source a review could draw on used to be something Build already knew. Nothing reached outside, so every claim about whether the code runs rested on the report of the agent that wrote it.
• A profile can now ask for two things. repo_gates runs your repository’s own checks in the worktree Station provisions, at the commit under review. pr_ci_results reads what your CI has already run, executing nothing at all.
• The set is bounded by your repository’s declaration and nothing else. A profile naming a check your repository has not declared is refused when it is saved. This is not general shell access.
• A gate that did not run is never reported as one that passed. Timed out, crashed, out of budget or skipped, it is recorded with the reason, and the reviewer still decides.
• A task that was both queued and dispatched could get two sessions on one machine, 27 seconds apart. Both paths now claim before spawning.
• Work done through a proxied client counts as yours again. It was being recorded as the agent’s own, which quietly discounted every verdict a person made through Cursor or Copilot.

The session count clears when the window is closed, and the Stop hook stops naming work that is not yours.

• macOS suspends a hidden window’s timers, so closing to tray could freeze the badge at whatever it last showed. Both the Dock badge and the tray title are now driven from the background process.
• Selecting Codex in a project could delete a [mcp_servers] section header you had written yourself, and the comment above it, the first time Station wrote to that file. Fixed and covered by a test.
• The hook that reminds a session about an in-progress task could block a session that had made no edits at all, naming a task it never started. Measured by a customer at 25 of 29 blocks over three weeks. It now judges only what a session itself changed.

Cursor, Copilot and Codex actually get their MCP config, and a review scans for secrets before it starts.

• Ticking a tool other than Claude Code always said configuration was written for it. It was not. .cursor/mcp.json, .vscode/mcp.json and ~/.codex/config.toml are now genuinely written, each in that client’s own format, against the same checkout.
• None of them carry a literal token. Each references MESHLY_AGENT_TOKEN from the environment, the way Claude Code’s config always has.
• gitleaks, osv-scanner and semgrep run when a review is requested, and findings reach Build alongside the review. Secret values are redacted before anything leaves the machine.
• The Dock icon badges the number of running sessions and the tray icon shows the same count. Both go quiet at zero.
• A review whose head commit cannot be pinned is refused outright, rather than silently falling back to whatever the shared checkout happens to hold.

A project can name the tools it uses, and say this machine will not run its work.

• A project carries a set of tools rather than one. A person can work in Cursor while Station dispatches Claude Code against the same checkout.
• Station can only spawn Claude Code. With it unticked, the project is declared manual-only and Build stops sending tasks and reviews here. The work is still tracked, reviewed and committed through Build; a person just drives it in their own tool.
• The consequence is stated next to the control, before the choice, not in a dialog afterwards.
• Switching tools is refused while a session is running for that project. Requires Server 3.8.5 or later.

A task now runs in its own project’s checkout, not its agent’s.

• An agent enabled in several projects has one directory, so a task for one project could run inside another project’s repository, and commit and push there.
• The checkout is resolved from the dispatched project. A dispatch for a project this machine has no checkout for is refused, with the project named.
• Anyone running an agent in more than one project wants this release.

A session claims its task before it starts, and a crashed Station gives its work back.

• Two machines handed the same task both used to spawn a session. The claim now happens before anything starts, so losing a race costs one request rather than a session.
• A finishing session opens its pull request instead of waiting for someone to notice the branch.
• A force-quit Station used to leave tasks pinned to a process that no longer existed. They are released.
• The agent list shows one row per session rather than per agent, so concurrent sessions stop hiding behind each other.

Contention isolates rather than queues, and a worktree starts from the default branch.

Station decides whether a running session is still fit to continue, and every check fails toward starting fresh.

• A reviewer session never continues onto other work.

No task is claimed without a slot to run it in, and a full Station stops asking for more.

• The wait is visible rather than silent.
• Sessions work on feature branches only.

The station-wide session ceiling has a control instead of living in a file the app owns.

• The field says what it bounds, that lowering it never stops sessions already running, and that each session is a full model process, so raising it raises cost and machine load in proportion.
• It applies immediately rather than at the next restart.

A review shares the checkout instead of waiting for it, and concurrency is counted per project.

• Per-project concurrency under a station-wide ceiling, so one busy project cannot starve the rest.
• A worktree is given back when its session ends.
• Every commit is resolved before a reviewer is spawned.

A busy checkout is waited out for six minutes instead of one.

A review refused because the checkout was busy is now waited out, then reported rather than dropped.

A refused key stops the poll and explains itself, then starts again on its own.

• Key expiry is warned about in advance rather than at the moment it stops working.
• Other server errors are no longer silent either.

Station runs automated reviews.

• A session records the commits it produced, so a review has the exact changes to look at.
• Reviews run against the project’s own working folder. If the right tree isn’t there, the review refuses to start rather than judge the wrong code.
• A reviewer’s session lasts as long as the review does.

Agent identity and personal identity stay separate on the workstation, so agent work is never signed off under your own account.

Credential changes take effect in seconds, without restarting the app.

• Agent keys are provisioned right after every sign-in and settings save, so agents are dispatch-ready within seconds.
• Sign in with your own account or a Personal API Key. Station tells you where to get one.
• The dashboard warns when an enabled agent can’t receive tasks, instead of looking healthy while dispatching nothing.

One Station, several Meshly organizations.

• Hold multiple named organizations and switch between them from the sidebar. Each keeps its own server URL, workstation registration, project settings, and credentials.
• Sessions always authenticate as the organization their project belongs to. Switching regenerates every enabled project’s config.
• Existing installs migrate into a named organization on first launch. Nothing to reconfigure.
• Prompt delivery to spawned agents is verified and retried, and idle detection watches the terminal pane so long-running work isn’t mistaken for a stall.

New agents in a project arrive enabled, so background dispatch picks them up without a manual step.

More reliable agent dispatch on macOS and Linux, including headless startup.

The menu-bar icon is now a monochrome Meshly logomark that adapts to a light or dark bar. Windows and Linux keep the color icon.

A dispatched agent works under the identity assigned to its task, whichever agent is the project default.

Linux polish.

• Toggles render clearly under webkit2gtk.
• The Linux package declares its dependencies, so they install automatically.
• Startup detects a missing dependency and shows the install command for your platform.

Keychain-backed credentials, and signed builds on macOS.

• The MCP key is read from the OS keychain at connection time instead of being written into a config file on disk.
• Per-session config files live in a user-private directory and are removed when the agent exits.
• New setting to retain agent session logs after success, for auditing.
• Release builds are signed and notarized, for a Gatekeeper-clean install.

The login screen shows the current server and lets you change it, so pointing a Station at a different instance no longer needs a trip to Settings.

Support for system-owned projects in the project list.

Workstation targeting, and task-tracking hooks in every project folder.

• Station identifies itself on every queue poll, so a task aimed at a specific workstation reaches that one.
• Each enabled project gets hooks that keep agent work tracked against a Meshly Build task.
• Settings files are merged rather than overwritten, so hand-added entries are preserved.

Window dragging and double-click-to-maximize work on macOS and Windows; a project created on the dashboard now appears locally on the next resync.

A task that was blocked and then moved back to To Do is picked up on the next poll, with no restart needed.

Each agent authenticates as itself, and dispatch is serialized per project.

• Background spawns authenticate as the agent the task is assigned to, so activity on the server is attributed correctly.
• One spawn at a time per project working directory, so concurrent agents don’t collide on the same files. Worktree spawns are exempt, since each gets its own tree.
• Newly synced agents arrive enabled, and stale disabled platform agents are corrected on resync.

Smarter recovery when agents go silent.

• Station now tries to re-engage stuck agents before giving up.
• Tasks are released back to the queue if an agent stays unresponsive, so other agents can pick them up.

Headless agents no longer hang on permission prompts; logs use your local timezone.

Each agent gets its own concurrency slot, so one busy agent no longer blocks the others.

Reliability fixes for headless agents handling file operations.

First pass at headless permission handling.

New logging system; agent log streaming is more resilient.

• Structured logs with on/off toggle and live level switching, front-and-center in the sidebar.
• Agent output streams more reliably across operator workstations.
• App launches from Finder now produce visible logs.

Reliability fixes for headless agents and prompt delivery.

Architecture scanner is built in. No extra setup required.

• Run architecture scans without installing anything extra; Station handles it natively.
• Claude Advisor runs on your existing Claude Code subscription. No separate API key required.
• Polished UI: toast notifications, command palette (⌘K), tabbed settings, native macOS and Windows look-and-feel.
• Sign-in is more resilient. Transient errors no longer require you to reauthenticate.

Live agent output in the dashboard.

• Watch agents work in real time, with the full Claude Code interface streamed to your dashboard.
• Automatic log-file cleanup keeps your workstation tidy.

First working release.

Codex alongside Claude Code, and an approval that ships the work.

• Choose the agent per person, per project, or per task — for writing code and for reviewing it. Claude Code and Codex run side by side on one board, an explicit choice on a task always wins, and reviews are routed to the machine that holds the code.
• Codex is accounted for on its own terms: a run resolves and keeps its own model rather than inheriting a Claude-specific one, and Codex session tokens appear in execution details without double-counting, with an unknown cost reported as unknown rather than zero.
• Approving a task can now land it on your default branch automatically. Enable it per project, keep it off where merges are handled elsewhere, and trust it either way — a landing that does not succeed sends the task back to Review instead of reporting done.
• The board proves what shipped. Merge state is read from your repository, every badge says how fresh its answer is, and where nothing has been checked yet it says so plainly. Squashed and rebased commits are recognised as landed.
• Reviews keep their pace. A run aimed at a busy machine holds its place in the queue, a cancelled run hands the work straight back, and a re-review always reads your current code — with clear messages about where a review will run and why it is waiting.
• Stronger isolation between projects on shared instances, and every review accounted for exactly once.
• A faster board, more room to work in, and in-app guidance that walks you from approval through to your default branch and explains every review badge on a task.
• Team-scale housekeeping: budget alerts reach the people who can act on them, and notifications reach everyone an event names.

An entry now carries a grade, and the grade is served with it.

• Agents were being served knowledge nobody had ever checked. Around a thousand entries, every one of them unverified, not because they were wrong but because nothing in the product had ever asked whether they were right.
• The grade runs unverified, corroborated, curated, verified, and is said in words beside the entry. An agent reading "one session reported this and nobody has checked it" treats it differently from a claim that has been read against the code.
• Curation is a pair of tools rather than a background job, because checking an entry means opening the files it names. A verdict of holds is refused without the paths read and the commit they were read at.
• A curated grade falls back when commits land after the SHA it was checked at. Nothing is retired by that: nobody showed the claim wrong, only that nobody has rechecked it.
• Knowledge was being served by recency across every project, so an agent asking about one repository was handed fragments from another. Retrieval is now semantic and scoped to the project.
• Station installers stopped downloading fleet-wide when the release registry began requiring credentials. The server now authenticates, and the version check stays open.

The reviewer checks whether the author’s claims are true.

• It read a diff and the author’s account of that diff, with no criterion asking whether the second described the first. "I ran the tests" and "the tests pass" were the same sentence to it.
• A verification claim nobody could check, a test named that does not exist, a command whose output is not shown, is now flagged as unverifiable rather than accepted or ignored. One unsupported line no longer taints the rest of an honest summary.
• A review profile can name the repository’s own blocking gates. Which checks must pass is the repository’s business, and a profile naming a gate the repository does not declare is refused at save rather than failing later.
• Calibration, the gate on whether an automated verdict can be trusted, was measuring the reviewer against the wrong thing in four ways. Each of them made it lie.
• A project can override or drop one workflow rule without taking all nine or none.
• A truncated activity history cost one customer a false review rejection and a false fabrication accusation on a permanent task record. It is now read from the endpoint that holds it.

Done now says whether the code is actually on the default branch.

• Work was reaching Done without reaching the product. Station’s main sat frozen for twelve days behind seven pull requests, six of them carrying tasks the board showed as Done, and one holding the fix for a defect that was live the whole time.
• A task is now shown as merged, or visibly approved but unmerged, and a Done, but not merged section on Reports gives that backlog a length. Approving ahead of the merge is still normal, and it clears itself when the pull request lands.
• The signal comes from the repository host’s pull-request webhook. Where none is registered nothing can be known, and the report says so plainly rather than listing every task as late.
• Four board transitions were silent: a review starting, a review failing, and a Station claiming or releasing a task. All four now reach the board without a reload.
• Breaking for anyone reading get_review directly. rubric_criteria[].annotations is now rubric_criteria[].annotation_indices, holding positions into rubric_annotations. The old shape sent every annotation twice, 91% of the response by bytes, measured by one customer at roughly 256,000 tokens across 130 calls.

Only a machine that serves a project may claim its work.

• This is why reviews had been dying across the workspace. A request goes to every Station running the addressed agent, deliberately, and the claim decides between them. The claim only checked the agent, never the machine.
• So a Station with no copy of the code could win, never start a reviewer, and leave the machine that did hold the code standing aside until the deadline passed and the review was recorded as failed.
• No Station needs updating and nobody needs to stop working. The refusal is one the current fleet already understands as someone else has it.

Reviews were being lost silently. Four faults, found by chasing one board.

• A queued review showed the same chip as a running one, and its tooltip asserted the first while the second was true. That is precisely the state that dies unread at its deadline, so it now renders as its own chip.
• A Station and an interactive session under the same agent name shared one mailbox, and whichever fetched first won. Simply looking at your tasks could consume up to five dispatches.
• A review nothing acknowledged was never offered again. The sweeper now re-offers unacknowledged reviews oldest first, bounded so a Station that is genuinely gone still stops.
• The Textual console is retired, along with the sign-in path that served it, which rotated a key and returned the plaintext in a redirect header. Station is the execution edge now, and it authenticates as an agent.

A workstation can declare that it will not take a project’s work.

• A machine set up for a tool other than Claude Code cannot run a dispatched session, so it says so per project at registration and Build stops targeting it.
• The refusal is written on the task, so work nothing will pick up never looks like work nobody has got to yet.
• A rejected task is no longer handed back to a machine when a person was driving it by hand.

A page shows what the agents are doing, and a session says which machine it is on.

• Queued and running work was a number with the detail hidden in a tooltip. Each row now opens the task it names.
• A review is dispatched to the workstation holding the code rather than whichever answers first.
• A claim taken before a session starts can be given back.

A task shows that it is being reviewed while the review is running.

• Work sent back by a review returns to the queue instead of stopping.
• A project page reports its active milestone.

A project that never chose a session-continuation rule follows the workspace setting again.

An agent session can carry on to the next task instead of starting over.

• The setting is a choice of three, not a switch.
• A reviewer never continues onto other work.
• A warm-started task says so on the board.

An agent can push work at a workstation instead of only waiting to be given some.

• Every dispatch is bounded and reported, the way reviews already were.
• A dispatch that cannot succeed is refused with the reason, before any compute is spent.
• The board’s bulk toolbar offers everything the right-click menu does, and refuses what the selection cannot take.

One customer’s activity could affect another on a shared instance. Fixed.

• A review that failed to run used to leave the task unable to be reviewed ever again.
• A busy server says it is busy instead of never answering.

A review that already reached a verdict can no longer be turned into a failed one.

• “Review failed” can be filtered for on the board.

A review that could not run says so instead of disappearing.

• A task’s commit list is readable and writable only by people and agents with access to its project.
• Registering an empty set of commits against a task is refused.

Automated review now covers work you did yourself, not only work Build Station ran.

• A review that does not happen says why.
• Completing a task tells you when it will not be reviewed.

A rejected agent key now records whose key it was and which one.

• An expired key no longer reports itself as a key that never existed.
• What the automated reviewer does when it rejects work is written down.

Automated review: a reviewer agent that reads the diff, on a charter you write.

• Turn it on per project and pick a review charter, which decides what the reviewer is shown, what it is asked, and what it must answer. Different work can be reviewed to different depth.
• Record only by default: the verdict is written down and nothing moves, so you can watch the reviewer agree with you before letting it act. Switch it to acting when you’re ready, under Settings → Project → Review Authority.
• Choose how many rounds of review and fix to allow before the task goes to a person. A skip-review label opts a task out.
• Verdicts appear on the task and on the board, each with its own filter. Approving or rejecting a task the reviewer already ruled on is labelled as overriding it.
• Charters are created, edited and deleted from the interface. The one that ships with the product stays read-only, and a charter in use by a project can’t be removed out from under it.

Meshly Data Stack planning tools reach a Claude Desktop conversation.

• Eight read-only orientation tools (what this stack is, what data exists, what depends on what, whether a plan’s assumptions hold) are now available where planning actually happens.
• Only that family crosses over. The operational surface of a connected data stack stays with the coding agents.
• They appear when the conversation has a project in focus and that project has a data-stack connection.

On shared instances, each customer keeps its own agent roles and model price list, and historical spend is filled in on the dashboard.

Task history you can query, and a connector that stays connected.

• Tasks record when each step happened and who caused it: started, completed, approved, rejected, cancelled.
• Approving work is a person’s act. An agent needs an explicit, expiring mandate to review a specific task, which only the automated review process issues.
• Deleting a task leaves a record of who did it, when, and what the task contained.
• A connector in daily use stays alive: the token clock runs from last use rather than from issue, so a conversation left open over a weekend still works on Monday.
• Moving a task from Review to Done records the approver, closes the linked support ticket, and confirms the knowledge captured along the way.

Knowledge coverage and staleness you can act on.

• Coverage is the share of finished tasks that carry a linked knowledge entry, reported with the counts behind the percentage so the figure can be checked.
• Six distinct staleness reasons, each with its own suggested action. An entry still in demand is proposed for revalidation, never archival on age alone.
• Knowledge usage counts both ways an entry reaches an agent: automatic context injection and explicit search.

The Desktop connector can plan, not just capture.

• Create projects, epics and milestones, set dependencies, record decisions, capture knowledge, manage labels, and link related projects, all from a conversation.
• Reviewers can approve and reject from Desktop. It is the one step in the loop that is the human’s by design.
• The human tool profile now carries 65 tools. Task execution verbs stay with the agents, since claiming a task from a chat window would collide with the agent doing the work.

Claude can identify itself with a hosted metadata document, so a connector is one durable identity instead of a fresh registration per connection.

A full audit trail for the connector, and scopes that mean what they say.

• Client registration, consent granted and denied, token issuance, refresh and revocation are all recorded, each naming the tenant, the user and the client.
• Read-only access is read-only. A connector granted read access cannot create or modify anything.
• The consent screen shows the real destination host before anything is granted.
• Expired connector records are cleaned up on a retention schedule.

Meshly Build can be added as a custom connector in Claude Desktop and claude.ai.

• Build acts as an OAuth 2.1 authorization server, with mandatory PKCE, refresh rotation with reuse detection, revocation, and audience binding. A consent screen names the client, the scopes, the instance and the account before anything is granted.
• A person’s session and an agent’s session are different things. People get a conversational tool profile for reading, planning, discussing and capturing; the execution verbs stay with the agents.
• The project a conversation is about is remembered per connector and survives app restarts.
• MCP Streamable HTTP transport alongside the existing SSE transport, on the same mount.

Every agent session opens with conduct rules: back a claim about system state with a fresh check, finish the scope you were given, and lead with the strongest objection rather than agreement.

Memory trust: knowledge the board can overrule.

• Memories record what they were derived from, and when.
• A task reopened from Done or rejected outright drops the memories that leaned on it. A rename marks them suspect, and they are served wrapped in the action that cast the doubt.
• The check happens when an agent reads, not on a nightly cycle, so disproved context stops being handed out immediately.
• Per-agent and per-model spend is computed server-side, so the dashboard and the budget limit see the same number.

Per-project control over the one-active-task rule, for operators running several sessions of the same agent, plus project environment docs for references and non-secret config.

Agents can set a task’s labels when updating it, not only when creating it.

On shared instances, a session is bound to the tenant that issued it. Dedicated instances are unaffected.

Cross-project worklog.

• An append-only worklog, plus a unified feed that merges worklog entries, task activity and decisions across a project and the projects linked to it.
• Agents record what they did and read recent activity across a whole project cluster.
• Agents can retrieve image attachments left on a task.

The customer portal loop, end to end.

• Task transitions update the linked portal ticket: started, resolved, waiting on the customer, closed. Each carries a customer-facing comment written in plain language.
• A triage queue turns incoming ticket clusters into work: verify into a new task, link to an existing one, or reject with a reason.
• When portal-linked work reaches Done, the originating intake card follows it.
• Portal settings are configured from the admin interface, with a health badge that says whether the connection is actually ready.

One active task per agent per project, enforced by the database.

• Cross-project work stays allowed. The rule is one active task per agent within a project.
• Context feedback accepts the full set of signals, and each one now drives real curation: quarantine and retrieval-time demotion for context an agent reports as outdated or wrong.

Workstation targeting is enforced on the server. A task aimed at one Station reaches that Station; untargeted work stays available to any of them.

Short task IDs on the board.

• Compact task ID badge added to expanded task cards and the detail dialog. Tap to copy the full ID.
• Matches the short ID format that agent chat and logs already use, so cross-referencing just works.

Image uploads accept more formats and recover from common encoding issues.

Clearer error messages when running MDS tools against projects that don’t have an MDS connection configured.

Faster, more reliable MDS connection handling for slower networks.

MDS tools appear immediately in fresh agent sessions instead of arriving on a delayed refresh.

MCP tool refinements: clearer errors, broader agent permissions.

• Project-scoped agents can now read errors, audit log, and project labels.
• MCP error messages surface the actual cause instead of a generic "Permission denied."
• Knowledge entry types are validated strictly. No more advertised-but-rejected fields.
• Cleaned up obsolete MCP tools that no longer had a working backend.

Better visibility on MDS connection issues, and broader credential access for project-scoped agents.

MDS tools reliably reappear after MCP reconnects in long-running sessions.

MDS tool catalog is leaner in single-environment projects, reducing session startup overhead.

MCP session resilience: fewer reconnects, faster tool listings.

• Tool listings return immediately; MDS tools attach in the background so first-use is faster.
• Sessions self-heal after deploy restarts, network blips, or laptop sleep/wake. Fewer manual reconnects.

MCP connections to existing project URLs work reliably.

MDS connection tests and health checks complete promptly instead of hanging.

Knowledge endpoint reliably returns recorded decisions.

MCP sessions stay open reliably.

• Long-running MCP sessions no longer get torn down silently every few minutes.
• Reverse-proxy configuration tuned so keepalive frames flow through cleanly to clients.
• Session-expired responses use a structured signal so well-behaved clients can re-handshake automatically.

Architecture overview for every project.

• New Architecture page renders eight standardized sections per project: overview, tech stack, entry points, flowchart, surfaces, data model, integrations, and a file tour.
• Diagrams are deterministic. Same inputs always produce the same view, no LLM at render time.
• Station scans your source, the backend stores the result, you can regenerate on demand.
• Retired the older documentation pipeline in favour of this leaner, more reliable surface.

Architecture diagrams render reliably for emit/subscribe relationships.

Architecture diagrams render reliably for components with explicit edge labels; component cards display file basenames with full paths on hover.

Architecture diagrams handle special characters in edge labels.

Architecture-doc generation is split cleanly between Station and the backend for better reliability.

Recover from stuck architecture scans without manual intervention.

Reliability improvements for user-initiated architecture regenerates.

First-time users see a Generate button in the architecture empty state.

Regenerate button now triggers a real architecture rescan.

Old `/docs` URLs redirect to the new architecture path.

Architecture-doc structure tightened to a fixed set of sections; legacy ingest paths removed.

Architecture-doc render surface and storage land.

• New Architecture page renders eight standardized sections per project.
• Diagrams are derived deterministically from the source data. No LLM at render time.
• Includes flowchart, ER diagram, and a file tour grouped by top-level directory.

AI-written documentation no longer leaks template placeholders into output.

Prose Regenerate now reliably triggers a fresh regeneration.

Documentation queue handles all date types; Schema view renders cleanly when empty.

AI-written project documentation.

• Long-form documentation is now generated by paired writer and reviewer agents to ensure citations are grounded in your project.
• Standardized section vocabulary covering system overview, data model, API surface, auth flow, deployment, conventions, and recent changes.
• New Prose tab in Project Docs with markdown body, citation footnotes, provenance and metadata indicators, and per-card regenerate.
• Workspace settings control auto-refresh, token budget, and producer choice.

Multiple polish fixes to the Architecture views.

Login page recovers cleanly from invalidated refresh cookies.

Architecture scan ingestion now succeeds reliably.

Workspace tab handles workspaces with many projects.

Failing architecture scans surface the actual error in the response.

Architecture tab numbering gap fixed. Workspace is now `04`, alongside Components / Schema / Flows / Timeline.

Project Docs handles all data shapes reliably; Genome consolidated under Project Docs.

Architecture V4.0: five interactive views and Ask AI.

• Five interactive Architecture views: Components map, Schema, Flows, Workspace, Timeline.
• Ask AI on selected components for grounded summaries based on neighbours and recent related tasks.
• Optional post-scan AI enrichment fills missing component descriptions, gated by token budget.
• AI-generated content is visually distinguished from scanner facts.
• Reload prompt when a new version is deployed; full keyboard navigation across views.

Project documentation consolidated into one surface.

• New Project Docs view with Overview, Architecture, Genome, Decisions, and Prose tabs.
• Architecture moved out of Settings where it had been hidden.
• Admins can author free-text markdown sections per project under Prose.

Server-side agent memory. Memories shared across machines and sessions.

• Memories scoped to workspace, project, or agent across four types (user, feedback, project, reference).
• Agent sessions automatically sync the latest memory snapshot at task start.
• MCP tools to save, list, and forget memories.
• Stale local memory files cleaned up automatically.

Daemon hardening. Survives outages and always restarts.

• Heartbeat retries cleanly on failure, with progressive logging instead of error spam.
• Daemon services always restart on macOS and Linux, including after clean shutdowns and OS updates.
• Workstation registration retries automatically when the network is down at startup.

MCP nudges: soft workflow guidance for agents.

• Complex tasks include a planning hint encouraging the agent to outline an approach first.
• Restarted tasks show the previous rejection reason; completion warns when no lesson was recorded.
• Higher-priority tasks get a quality reminder at completion.
• Error tools flag untracked groups with frequent occurrences and suggest creating a task.
• Agents are guided to use subagents for research to keep their main context focused.

One-command machine setup.

• Authenticate, fetch all agents and projects, scan local repos, and write per-project configurations in one shot.
• Rotate all agent API keys during setup with a single flag.
• Reconfigure regenerates configurations after AI tool updates wipe them, with no network access required.
• Dry-run mode previews changes before writing; credentials kept out of source control automatically.

Reports + MCP follow-up nudging.

• New Reports chart: task distribution by label, broken down by board column.
• MCP nudges agents to create follow-up tasks instead of leaving inline TODOs.

Workflow guardrails for agents.

• Single-active-task enforcement. Agents can’t start a new task while another is In Progress.
• Workflow-aware error messages with concrete remediation steps instead of generic "permission denied."
• Task-mutation responses carry next-action hints.
• Mandatory workflow rules surfaced through the workspace context; tool descriptions state prerequisites explicitly.

MCP tool surface expanded.

• 34 new MCP tools across labels, reports, error tracking, audit log, automation, knowledge, decisions, project relationships, and milestones.
• Agent learning loop: useful feedback reinforces matching knowledge entries; entries decay over time without reinforcement.
• Nightly snapshots pre-compute Reports data for instant load.
• Real-time updates for activity, auto-blocking, and budget warnings.
• Inline label creation from task dialogs with a colour picker.

Project intelligence layer.

• Knowledge staleness tracking. Entries with negative feedback signals are flagged as stale; consistently unhelpful entries auto-deactivate.
• Tiered memory: pin essential context as "always" so it’s injected into every agent session.
• Knowledge deduplication detects near-duplicate entries on save and on demand.
• Automated model routing scores tasks for the best Claude model based on task characteristics.
• Reports filters: scope by user, preset and custom date ranges, shareable URLs.
• New MCP tools to list project agents, bulk-create tasks, and register a project’s module map.
• Tighter project context responses with relevance thresholds to prevent context bloat.

Friendlier model name handling across UI and MCP.

Per-role model selection. Choose which Claude model each agent role uses.

Workstation tracking on tasks. Running cards show which workstation is hosting the agent, with a picker on invoke when multiple are eligible.

Live console page. Admin-only terminal viewer for agent sessions, streamed in real time.

Resolution confidence stored directly on tasks; agent roles fully manageable through the UI.

Epics, swimlanes, and the agent learning system.

• Epics group related tasks into feature-scoped initiatives that span milestones, with progress tracking.
• Board swimlanes group tasks by epic, milestone, assignee, or priority. Card display toggles, saved views, multi-criteria filter toolbar.
• Per-agent knowledge entries with confidence scoring; automatic learning from task completion, approval, and rejection.
• Capability profiling tracks which task types and labels each agent handles best; rejection-pattern analysis surfaces failure modes.
• Agent avatars.
• Agent permissions simplified to two tiers.

Enterprise major release. Production database, role-based access, agent guardrails, and unified settings.

• Migrated to a production-grade database for scale and reliability.
• Three-tier human user roles (Admin, Dev Manager, Viewer) with SSO group mapping.
• Project membership access control. Non-admin users only see projects they belong to.
• Agent communication system: human-to-agent, agent-to-agent, and broadcast messaging.
• Agent guardrails: role definitions, project-level access control, token and spend budgets, API key expiry, stale-task detection, time tracking.
• Unified Settings shell with persistent left sidebar; scattered config pages consolidated.
• Two-way Slack integration replaces one-way webhooks.
• Container deployment alongside the existing process-manager path.
• Two security audits with hardening across the API surface.

Notification card render fix; full-width Reports layout; responsive two-column Project Settings.

Onboarding, branding, and developer infrastructure.

• Interactive setup wizard for first-start. No more hardcoded admin credentials.
• Backend and frontend test infrastructure plus CI integration.
• Meshly dark theme with glassmorphic effects and animated gradients.
• Demo data seeder for evaluation; built-in backup management UI.

Agent question workflow, activity sidebar, and analytics.

• Agents can ask questions without blocking a task. Real-time notification bell with badge count and toast.
• Agent Activity sidebar shows active agents and their In Progress tasks with live elapsed timers.
• Token usage tracking per agent / model / task; Reports dashboard with completion trends, AI work time, and cost estimates.
• System audit log with timeline view; rate limiting for API keys; full-text search on tasks.

Initial release.

• Kanban board with drag-and-drop; AI agent integration via Model Context Protocol (MCP).
• MCP client package for VS Code Copilot, Claude Desktop, Cursor, and Windsurf.
• Real-time updates with project-scoped subscriptions; Slack webhook notifications.
• Milestones / sprints, global and project-scoped labels, JWT and API-key authentication.
• User and agent management; project settings (columns, labels, integrations).
• Production-ready deployment with HTTPS and CI/CD.