What's shipping in Station and Server.

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.

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 USD 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.