AtlasMind

_{· Current source version: 0.382.6 ·}

BETA
Your AI delivery team, inside VS Code.
Describe what you want built. Watch it get done. Keep every decision.

Install from the VS Code Marketplace · Get started · FAQ

What is AtlasMind?

Most AI coding tools give you one assistant in one chat box. AtlasMind gives you a team.

Ask for what you want in plain English. AtlasMind picks the right specialist for the job, picks a model that suits the task and your budget, reads what it needs from your project, does the work, checks it, and shows you exactly what changed and what it cost.

The important part is what happens next. Your decisions, architecture notes, lessons learned, and run history stay with the project — not in a chat window you'll close and never find again.

You stay in charge throughout. Nothing risky happens without your approval. Every automatic step is one you switched on, and you can switch it off again.

Who it's for

• Solo developers and freelancers who want the coordination of a bigger team without hiring one.
• Small teams who need a shared, reviewable way of working rather than everyone prompting differently.
• People learning professional practice — the guided workflow explains why each step exists, not just what to click.

You do not need to be an AI expert. You do need a project you care about getting right.

What you can actually do with it

Fix or build something. Ask in chat like you'd ask a colleague. AtlasMind looks at your code, picks a specialist, makes the change, verifies it, and reports back.

Run a whole piece of work. /project Add Stripe checkout produces a reviewable plan — the steps, what depends on what, what it will touch, where it will pause for you — before anything happens.

Chase a goal on its own. /loop and Mission Control keep working towards an outcome inside limits you set: how much it may spend, how long it may run, how many attempts it gets, and where it must stop and ask.

Think before you build. The Ideation board lets you lay out problems, requirements, risks and evidence, argue with yourself visually, and then turn the cards that survived into real roadmap items.

Ship properly. A guided eight-stage GitHub workflow takes you from an idea to a released version — issues, branches, pull requests, review, CI, release — with a clear explanation at every step.

Design an interface, then carry it into the project. UI Studio works with websites, web and mobile apps, desktop tools, editor extensions, embedded interfaces, and custom surfaces. It keeps screens, flows, wireframes, content rules, real Markdown copy, UI-system decisions, and source-code handoff guidance together. Its full preview opens in VS Code's built-in browser and combines the saved wireframe, UI tokens, and exact Markdown copy; a separate responsive lab checks fixed device widths. Website projects additionally retain the guarded sitemap, stack, hosting, and delivery workflow. Select any block and describe it in plain English; every profile can generate a reviewable HTML visual guide even when the eventual implementation is native rather than HTML.

Get started in five minutes

1. Install AtlasMind from the Marketplace.
2. Run AtlasMind: Manage Model Providers from the Command Palette (Ctrl+Shift+P) and connect one provider. Already pay for Claude, ChatGPT, Copilot or Qwen? You can use that subscription instead of an API key.
3. Open your project.
4. Tell AtlasMind about it — @atlas /bootstrap for a brand-new project, @atlas /import for an existing one.
5. Ask for something.

That's it. The Getting Started guide covers the longer version.

Bring the models you already pay for

AtlasMind does not sell you tokens. Connect whatever you already have:

• Cloud providers — Anthropic, OpenAI, Google Gemini, Azure OpenAI, Amazon Bedrock, DeepSeek, Mistral, z.ai.
• Subscriptions you already own — a Claude, ChatGPT, Copilot or Qwen plan, or an eligible Gemini Code Assist licence, used as routable capacity with no per-token cost.
• Local models — Ollama, LM Studio, or anything else that speaks the OpenAI API. No key, no bill.

AtlasMind then chooses between them per task, based on what the task needs, what's healthy, what's fast enough, what it costs, and what has actually worked well for you before. Set a daily spending cap and it will respect it.

See Model Routing for how the choice is made.

Safety you can see

Ambitious automation is only worth having if you can trust it. AtlasMind is built so you can check it:

• Nothing risky happens silently. Writes, external calls, and destructive actions ask first — and you choose how often it asks.
• Your keys stay in the OS keychain. Never in settings files, never in your repository, and redacted before anything is sent to a model.
• Work gets verified. Configured checks run after changes, and a run cannot report success while its own verification failed.
• Production is protected. Promoting to production is deny-by-default until the backups and approvals you required are actually there.
• Everything untrusted is treated as untrusted — issue text, web pages, model output, files. None of it can quietly become an instruction.

Full detail in the Security model and Tool Execution.

What's new in 0.382.6

• The Project Dashboard now keeps user-authored Director text out of HTML parsing. Assignment and follow-up values are applied as text after the static controls render, removing the XSS data flow reported during release review.

• Delivery stage editing writes only declared fields. A fixed allowlist replaces recursive dotted property assignment, so altered webview markup cannot traverse JavaScript prototype keys.

What's new in 0.382.5

• Worktree cleanup is portable without weakening its safety boundary. Git-reported drive-letter and UNC paths stay absolute even when AtlasMind is running on a POSIX automation host, and relative paths follow the workspace root's path syntax. A registered Windows worktree is no longer misclassified as an unrelated path by Linux or macOS release checks.

What's new in 0.382.4

• Cleared or rewritten chat history cannot survive in AtlasMind's rolling context. Each session now carries a persisted transcript revision, and every derived context bundle records the revision it summarizes. A mismatch is refused and the current raw transcript is used instead.

• Context invalidation is ordered, not best-effort. Clear, Delete Message, Delete Session, New Chat, Edit, and Regenerate wait for older maintenance before removing its artifacts. A delayed summarizer cannot recreate a stale context directory after the destructive action completes.

What's new in 0.382.3

• The next Chat reliability programme is approved and bounded. The implementation plan makes transcript revision the context authority, converges the dedicated and native chat paths, and evolves the existing heuristic selector plus find-tool loop into a model-budget-aware capability broker. Installed external capabilities remain deny-by-default and require explicit one-turn elevation.

• Success is measurable before implementation begins. The plan sets gates for stale context, lost turns, capability recall, schema-token reduction, authorization escapes, keyboard access, and the live stress battery. See the Chat reliability and capability broker plan.

What's new in 0.382.2

• Delivery chat keeps the Git facts it asks Atlas to resolve. Opening a non-green working-tree step now rechecks the live repository instead of rebuilding the runbook with cleanliness marked unavailable. Approval-qualified release wording no longer disables every command-capable Git tool.

• Commits can stage and commit exact paths, including intentional untracked files. git-commit accepts a bounded path list, leaves unrelated pre-staged changes out of the commit, refuses ., traversal, absolute paths and pathspec wildcards, and names that scope in the approval summary. The GitHub Operator is explicitly barred from recommending git add . or inventing a commit-message file it did not inspect.

What's new in 0.382.1

• Roadmap and workflow artifacts are synchronized. The project memory records and roadmap graph metadata are regenerated so existing backlog entries and roadmap links stay consistent with the latest source updates and execution history.

• Roadmap backlog text remains the SSOT source for this cycle, with updated priorities and dependencies tracked in canvas-facing metadata.

What's new in 0.382.0

The last Marketplace publication, v0.369.3, is the baseline — everything below is in it. The full history is in CHANGELOG.md.

• The dependency canvas is readable when it is dense. Click a card's body and its neighbourhood lights up while everything else recedes; a toolbar search shows only matching items plus everything connected to them; fans of edges spread across each node's face instead of arriving as one knot; edges are quieter by default and layers get more air.

• The dependency canvas lays out as a readable tree. A compact, deterministic Sugiyama pipeline replaces the naive pass: prerequisites sit just before what they unlock instead of piling into one giant first row, unrelated sub-plans lay out as separate blocks whose edges never cross each other, crossings are swept out, children settle under their parents so chains draw as straight lines, and unlinked items park in a compact block of their own.

• Every canvas action now actually reaches the host. Fifteen roadmap messages — drags, saves, links, Calculate tree, the Atlas pills, the register hand-offs — were being silently dropped by the dashboard's message gate, which knew nothing about them. All are now admitted with proper shape checks, a dropped message reports itself instead of vanishing, and a parity test pins the message union, the handler switch and the gate to one list so this class of dead button cannot ship again.

• Saving a roadmap node works, and the roadmap wires itself up on first load. The canvas and the save path could resolve an item to two different ids when its line had no hidden anchor yet, and every save against it missed silently. Both now resolve through one shared function; a save that still cannot land says so and refreshes the canvas; and the hidden per-line ids are written once when the dashboard loads instead of on your first change, so every item is durable before you touch anything.

• Every roadmap entry carries three Atlas pills, and files its plan. Plan creates a dedicated plan document under roadmap/plans/ (a deterministic scaffold, created once, never overwritten), links it to the item as its filing record, and hands the drafting to Atlas in chat. Resolve hands the work over, following the filed plan when there is one. Completion check reports — with evidence — whether the item is actually done, and never ticks it off: marking work complete stays a human act. The pills sit on the canvas cards and the backlog rows alike; a delivered entry keeps only the check.

• The roadmap canvas responds like a canvas. Pan, zoom and fit apply straight to the view instead of rebuilding the whole dashboard per wheel tick; a drag-drop redraws in tens of milliseconds rather than recollecting every page; zoom anchors at the cursor; a plain wheel pans instead of scrolling the canvas away; the whole card drags, not just its title bar. The tree itself got readable: siblings sit beside what they wait for, rows no longer overlap chip-heavy cards, arrows anchor to each card's real height, and the one-column "nothing linked yet" state offers Calculate tree in the banner that explains it. A background refresh can no longer eat a drag in flight.

• Say how you version, and the dashboard reads it. A project with several branches has one release line, not one number per branch — but AtlasMind only ever knew the manifest's, so every delivery stage reported whatever that branch's copy said. A versioning block in the workflow file now declares a scheme, where the number comes from, and what each branch produces: develop making 1.5.0-beta.3, main making 1.5.0, the same line at two points on its way out. The Release page shows what the current branch would produce next and the rule that decided it; the header names each branch's channel. Nothing is assumed — a project that has declared nothing is told so and shown what would be suggested, and nothing here writes, tags or publishes a version.

• The dashboard tells you when it has stopped being connected. A webview outlives the extension object that answers it, so after an update or a host restart the Project Dashboard could come back looking perfectly healthy and be inert — hover worked, moving between pages worked, and every button posted into nothing. It is now re-attached to a live host when VS Code restores it, and if a request goes unanswered the Refresh spinner stops and a banner says what happened and how to get out of it.

• Gaps, debt and risks can become work. Every finding in all three registers now carries Add to roadmap and Raise as issue. Both are derived rather than typed — you see the exact line before anything is written, and an issue draft opens in the composer where your confirmation is still the only thing that posts it. A raised item says where it came from and routes back; the register says "on the roadmap" rather than letting you raise the same finding twice.

• Arranging the canvas. Fit all beside the zoom controls puts the whole plan on screen. Snap to grid lines a dragged node up with the auto-aligned ones. Auto tree lays the plan out as a tree and fits it on screen, with → and ↓ beside it choosing which way the tree runs — releasing hand-placed positions rather than freezing this moment's arrangement, so the next item added lands in its own column. Arranging always re-fits, and so does adding an item: a re-flow moves every node while your pan stays put, so without the fit the result happens off-screen. And Calculate tree, carrying the AtlasMind mark, works the whole dependency tree out from the wording of your backlog and offers it behind one confirmation that says how many links it would add — which is the control that actually builds the tree, because a suggestion is drawn dashed and deliberately moves no item until you accept it.

• Bring the roadmap you already have. Import… on the Roadmap page reads a plan from markdown files across a glob, GitHub issues, a GitHub Projects board, or a CSV/TSV export. It imports rather than mirrors, and it is re-runnable: each line records where it came from, so a second run updates what moved instead of duplicating everything — and a first import adopts items you already typed by hand rather than adding them twice. Nothing is ever deleted; an item the source has lost is reported and left alone. Your edits are never overwritten — when both sides have changed you get a conflict showing both texts and nothing is written. The confirmation names what would be added, retitled, left alone and skipped before anything happens.

• The roadmap can say whose work it is. Assign an item from its node editor, from your Project Director roster, and switch to the By person view: the same outstanding work in one band per person, each band still ordered by what has to happen first, so an arrow crossing bands is one person waiting on another. Assignment is deliberately separate from who raised the item and who finished it — those are history, this is a plan. Work assigned to somebody later removed from the roster is kept and labelled, never quietly reassigned to nobody.

• The Roadmap is a dependency canvas, not just a list. A list can say which item matters more; it cannot say which one cannot start until another lands. The Roadmap page now opens on a draggable graph — nodes carrying the item, its branch name, its deadline, the days left and an estimate; arrows carrying what has to happen first. Route on any node hides everything that is not that item or a prerequisite of it, and says how many days of work are left on that route. The prioritised backlog is unchanged and still the only place drag-reorder sets Atlas's next-work weighting.

• Atlas proposes the links and applies none of them. Three declared rules produce suggestions, drawn dashed, each naming the rule and the evidence behind it. A suggestion moves no column, blocks no node, cannot contradict a link you drew, and cannot make the plan circular — and changes nothing until you accept it. Dismissing one is remembered.

• Estimates come from a published table, never a model, with a per-node AI-assistance toggle. The same backlog grades identically on two machines, which is what makes an estimate on a committed plan worth comparing.

• Delivered work gets its own canvas — laid out by month, keeping the links between pieces of work, recording when each landed and by whom. Completed work stays on the plan only while something outstanding still depends on it.

• Agents hold the whole local git lifecycle as real skills. Five new built-ins — git-worktree, git-fetch, git-pull, git-merge, git-stash — plus a git-branch that can list merged-only candidates and delete locally, force, or on the remote (protected branches refused). Previously a branch cleanup ran as seventeen improvised terminal commands and stalled on a locked worktree; worktree removal now knows the Windows read-only/OneDrive failure mode and only ever targets a worktree git itself lists.

• Git requests select git tools reliably. The intent pattern now matches inflected words ("branches", "merged", "pushing"), integration flows select git-merge itself, and a cleanup request selects git-branch + git-fetch + git-worktree together. Local git skills are graded by what they do (argument-aware), instead of falling through to a network-risk "external tool" grade that blocked read-only turns and confused approval dialogs.

• Two observed failure modes closed at the prompt. Models are told the per-turn tool-call ceiling before they hit it (a run died requesting 9 tools against a limit of 8 it was never told about), and told that the visible tool list is a task-scoped selection — call find-tool before declaring a capability blocker, which is exactly how a gap-analysis run wrongly concluded it could not edit files.

• The local CI queue command is findable when you need it. The borrowed-machine drawer on Pipeline → Rules closed the moment the machine read ready — exactly the state the setup journey sends you there in, looking for the queue command inside it. It now stays open, with the executors card leading the view, until one trusted job has actually completed. And the queue step pre-empts gh workflow run's misleading HTTP 404: workflow not found on the default branch: the file is not misplaced — GitHub only registers dispatchable workflows from the default branch, so merge the file there, or push a commit to the trusted branch instead.

• CI failures are legible again. GitHub returns Actions logs with their colour codes caret-encoded — a failed Windows run carried 7,253 literal ^[ sequences and not one real escape byte — so the stripper had nothing to match, every code survived into the text, and the rules, which match on word boundaries, could not see 1 failed through the ^[[31m glued to it. Every failure classified as unknown above a box of raw escape garbage. The same gap sat on a redaction boundary, since colour is stripped before secrets are redacted precisely so a wrapped secret still matches. The card now names the job, the step, the class, and the failing test.

• Where next. Every page carries a declared strip of routes to the pages a reader is likely to want, each stating the question it answers. Declared rather than derived, so the routes can be reviewed in a diff instead of shifting under the reader.

• A pull request row leads with its checks. A failing rollup names the failing checks, links to one, and routes to Pipeline — rather than leading with "awaiting review" while the fact that decides whether the branch can merge sat further down the page.

• No more silently greyed buttons. Check GitHub queue was disabled with no reason shown, and its gate disagreed with the tick directly above it. A disabled action now says what is holding it and offers the control that clears it.

• The promotion dialog stopped fighting you. Ticking a confirmation threw you back to the top of the list every time, so a promotion with nine checks meant nine scrolls back down; the run buttons sat below every check rather than staying in view; "Ask Atlas to fix this" on a failed step did nothing at all, because the message was being dropped one layer before its handler; and a running promotion could not be closed, even though closing it was always safe. Each section now carries a meter, the footer says what is still outstanding and keeps the buttons in view, and a run in flight can be closed with Escape or a button that says plainly that the run continues — with a strip on the Delivery page to bring you back to it and report how it ended.

• Auto-refresh moved into the Refresh button, and now works from any page. The cadence used to be four buttons and a paragraph parked on one card of the Pipeline page, taking up space permanently for a setting you choose once — and it stopped polling the moment you looked at anything else, which is precisely when you set "every minute" in the first place. It is a caret on the Refresh button now, including the one in the dashboard header, so it is there wherever a refresh is. An interval that is running shows on the caret without opening anything, the menu says what it costs, and the two rules that matter are unchanged: nothing is fetched while the panel is hidden or while a refresh is already running, and Off is still the default. Existing cadences revert to Off once, because the setting now means something slightly different.

• A local CI job keeps running when you close VS Code, and is waiting for you when you come back. That was always half true — the container kept going, because GitHub is waiting on real work and killing it would throw away minutes of compute — but nothing looked for it afterwards, so the page said the machine was idle while a runner held its whole budget. AtlasMind now finds it, reattaches to its output, and records the result when it ends. Containers left behind by a run that crashed are listed with a button to clear them, never removed on sight.

• /ship refuses a message a shell would read as syntax. Text typed after /ship was substituted into a routine's command line unchecked, which for a step like git commit -m "${message}" is a command-injection path. It is now refused before any step runs, with the offending characters named.

• The Project Dashboard opens on the dashboard. Its header was a generic 44px title, a three-line description of the tabs directly beneath it, a pill row, and then two full-width cards — one repeating the project name, one holding a 150px score ring — which is most of a screen before the first real signal. It is one band now: your project's name is the largest text on the page, the line under it is the project's health summary rather than a list of the tabs below it, provenance is one muted line, and the score is a chip beside Refresh that opens the Score page, where the full ring now lives.

• Local testing gets a sliding scale, and the operating system gets a guaranteed floor. One machine-scoped setting, atlasmind.testing.resourceShare, now bounds every path that runs tests on this computer — the after-write auto-verification, the test-run skill, the Pipeline's "Run here" commands, and the trusted local CI container. The budget is the lower of the share and what the OS reserve leaves, and the reserve is aggressive on purpose: at least 25% of the machine, never fewer than 2 CPUs or 8 GB, measured on the real host rather than the Docker/WSL VM. Jest and Vitest runs get --maxWorkers, Stryker gets --concurrency at a harder cap, every governed Node process gets a heap ceiling, agent-issued commands run at below-normal priority — and the live one-job runner finally has a Stop button. An ungoverned Jest-plus-Stryker default was fanning out to (cores − 1) whole test runtimes, which is how a mutation run can black-screen a 64 GB machine.

• A missing prerequisite announces itself. With local CI enabled, the Pipeline page now runs the machine inspection automatically the first time nothing has ever been probed and nothing is remembered — so "Docker Desktop is not installed" is the first thing on the page, not a discovery behind a button.

• The Pipeline stops asking you to set up what you already set up. Reopening VS Code used to send the Runner view back to "Inspect this computer" and "Check the trusted workflow", because neither answer survived the extension host. The workflow verdict is now re-derived from the file on every refresh — it is one file read, so it cannot go stale — and the machine inspection is remembered as a dated observation: the page says when it was taken, a record older than a fortnight or describing a different computer is refused, and nothing remembered can authorise a run, because the runner inspects again immediately before it lends the machine.

• Closing an issue or merging a pull request updates the page immediately. The write was always fast; the dashboard then re-read the entire repository — issues, pull requests, workflow runs, labels, milestones, releases, and sometimes a CI log download — before showing you anything. What gh confirmed now appears at once, each part of the re-read publishes as it arrives, and a refresh asked for while one is already running is run afterwards instead of being dropped.

• The test suite leaves you half your machine. npm run test was spawning one worker per thread — 23 of them on a 24-thread machine, each writing real project trees to disk — which made the editor unresponsive for as long as the suite ran. It now uses 50% of the machine locally and the full default in CI, where nothing else needs to stay responsive. VITEST_MAX_WORKERS still overrides it.

• Atlas action buttons are pills now, everywhere in AtlasMind. The Atlas mark on the left says who is being asked; a glyph on the right says what they will do. "Ask Atlas" names who and never what, so a row of these was a row of identical circles you had to hover one at a time. The tooltip still carries the whole sentence — the glyph narrows the meaning, it never has to carry it alone.

• The canvas panel sits beside the graph where the window is wide enough. Below it, selecting a workflow scrolled its own answer out of view.

• Declared policy rows now open the policy. A row on the Tests view can say a policy is unevidenced; only its card on the Testing page can say what it would take. Clicking through opens that card expanded. Cross-page links to a policy had been silently landing on the right page with no record for as long as the link existed.

• act, Buildkite and Woodpecker link to their own documentation rather than naming a hostname you had to retype, and an executor nothing routes to reads optional rather than needs setup.

• The canvas is now the CI/CD hub. Three overlays on the one graph rather than three separate views: Status paints the latest outcome on each workflow from the same runs Activity reads, Routing says where each kind of check runs, and Delivery appends the stages a commit travels through after the gate — so CI and CD are finally one picture. Click a workflow for its panel: last result, its file, and every action that applies to it. Dragging still changes nothing but the layout.

• Tests answers three questions instead of one. What is failing right now — with the file, the policy it belongs to, and a button to open it — then whether your declared testing policies are actually evidenced, then the band that was never surfaced: declared endpoints, roles, migrations and schemas that no test names, each with a Draft with Atlas action. That scanner has existed for months; nothing on this page ever showed you its results. A report older than your newest test file now says so.

• Rules is now a grid, not a wall of prose. Every kind of check against every place it could run: preferred route, fallbacks numbered in order, and squares the policy refuses — each naming its reason on hover, so the rule that unreviewed code never reaches an unsafe route is visible law rather than a paragraph. One click cycles a square between unused, last resort and preferred, decided by the same engine that routes for real, confirmed with the sentence describing the change, and written to the committed file. Beside it, a dry run showing what would happen if checks ran right now, and executors compressed to one line each with the borrowed machine's detail behind a drawer.

• The Pipeline page is being rebuilt around four views. Phase A lands the shell and the landing view: Activity (watch), Canvas (understand), Tests (verify), Rules (decide) — named by what you are doing, not by which subsystem produced the data. Activity opens the page and leads with what needs you: the classified failure with its evidence and a one-click handoff to Atlas, then a run ribbon per pipeline where bar height is elapsed time and colour is the outcome, then everything that ran. Setup is no longer a tab; it takes over only while genuinely unfinished, then retreats to a chip. The Analytics and Builds tabs are gone — the ribbon replaced the donut, the waterfall and the pills.

• The Pipeline page answers its own five hardest questions. Onboarding stops being the landing page once anything has run — the page opens on Builds, and the setup journey collapses to one line with the steps behind a disclosure. The routing card says plainly what the rules are and every rule has a Change… flow, so picking where checks run no longer means editing JSON. The latest classified failure now renders on Builds with Ask Atlas to work on this failure — the log fenced as untrusted content. Analytics leads with sentences ("2 of the last 30 completed runs failed; the least reliable workflow is CI") computed from the same numbers as the charts. And the Builds and Where-it-runs tabs, which shipped unreachable behind a stale allowlist, actually open.

• Routes now say how faithfully they reproduce what they claim to prove. act and the borrowed machine both produce Linux-container evidence, but one runs GitHub's own runner image and the other emulates artifacts, caches, services and secrets. Nothing in the model could tell them apart, so a routing rule could substitute one for the other unopposed. Now packaging and security scanning demand the real thing and refuse an approximation — while the full suite accepts one, because under act your tests genuinely run and it is the orchestration around them that is emulated.

• The test suite is type-checked at last. Tests were never covered by the build config, so a fixture could claim a type it no longer satisfied and nothing noticed. npm run typecheck:tests checks them, and a baseline holds the existing count so it can only go down — a new test that does not type-check now fails the suite and is named in the failure.

• Run your existing GitHub workflow locally with act — after being told what it cannot reproduce. Any workflow on the map now offers Run locally with act. AtlasMind reads the file first and says which parts will not behave like GitHub: artifacts and caches have no local service, secrets are absent so steps needing one often pass for the wrong reason, and the event payload is synthesized. A job targeting Windows or macOS, or using OIDC, is refused outright rather than run as something else with the same name. The command goes to your terminal for you to run — AtlasMind will help you run act and will not run it for you, because it executes arbitrary workflow content with container access.

• One build list, and it never invents a verdict. A Builds view merges local runs with GitHub's, newest first, so you can see what this project has actually run lately. How closely each build was watched is part of the record: a tick or a cross means AtlasMind saw the result, and a question mark means it started the run and cannot see how it ended — which is the honest answer for the run-here route, whose commands go to your own terminal. Hosted builds refresh while they run, by polling with backoff, and the page says so rather than dressing it up as a stream. Local history is yours alone: it lives in workspace state, not in the committed project memory.

• Routing rules decide where each kind of check goes, and one rule is not yours to change. A committed ci-routing.json records which route serves fast feedback, the full suite, packaging, security scans, the platform matrix and unreviewed contributions — and what each does when the hosted allowance runs out. Every decision names the rule behind it and explains, in a sentence, why the others lost. Unreviewed code never falls back to a local route, whatever the budget says: that filter runs before the meter is consulted and applies to every fallback, so running out of hosted minutes produces a refusal rather than moving somebody else's pull request onto your computer. AtlasMind can read your Actions allowance to make budget-aware rules act on a real number — and when it cannot read it, it says so and keeps using the preferred route, because a billing endpoint having a bad afternoon must not relocate your work.

• Pipeline now shows where a check can run, and lets you just run it here. A Where it runs view lists every route — run here, lend this computer to GitHub, GitHub-hosted — with what each can do, what it costs, and whether this machine can use it today. Each states what a pass on it proves: a Linux container is not evidence about Windows, and AtlasMind refuses that substitution rather than leaving you to notice it. The simplest route finally has a button: Run these checks now resolves your project's own check scripts by a published rule, shows them, and types them into a terminal for you to run — and refuses outright if one of them would leave your machine. act, Buildkite and Woodpecker are listed as adapter boundaries: visible, never pretending to be usable.

• /localci walks you through local CI, and AtlasMind can install the GitHub CLI for you. Local CI has more prerequisites than anything else in AtlasMind, and now has a guide that derives each one from your machine rather than asking. It installs and enables nothing — every step opens the screen where you decide — and its last step is proving one job has actually run, because configured is not the same as working. A missing gh can now be installed from the Runner view, with the exact command shown first and success confirmed by re-checking PATH rather than by an exit code. An arm64 machine is told plainly that the shipped runner image is the reviewed x64 digest, which setting to change, and how to get the right one, instead of meeting a confusing pull failure.

• AtlasMind writes the trusted local-CI workflow, and checks it before anything else. The file that authorises a GitHub job to run on your machine has the strictest contract in the product, and used to be the one artifact you had to hand-author from a template. The Runner view now offers Check the trusted workflow — a file read, so it works before Docker, a GitHub sign-in, or a queued job exists — and Write it for me… when none is present. The generated workflow is derived from the repository's own remote, branch, runner label and package scripts, and the confirmation says in plain words what it will permit and refuse. Creation never overwrites. When a workflow fails the policy, each failed rule is listed separately with the change that satisfies it, instead of one sentence at the end of a four-step setup.

• Follow CI as a workflow, then zoom into the evidence. Pipeline Studio opens with four plain-language decisions—choose the checks, prepare the computer, queue GitHub, then lend one temporary runner—and shows only the next required action and a compact progress strip by default. Completed setup detail, specialist dashboards, and recent history are progressively disclosed instead of lengthening the setup path. Pipeline Studio separates workflow mapping, the local runner, tests, analytics, and packages/monorepo context into focused views. Measured status dials resolve to ticks; the read-only node graph can be rearranged with a pointer or keyboard; current test reports animate into honest pass/fail/skip cells; and bounded GitHub history drives outcome, answer-time and per-workflow reliability charts. Missing history, timing, registry or report data stays labelled unknown rather than being rendered as a healthy zero.

• Set up local CI without guessing what “enabled” means. The Runner view now explains that no permanent runner daemon is required and checks permission, PATH, Docker engine, GitHub authentication and the pinned runner image as distinct states. Missing software opens a fixed official installation page and is clearly described as an operating-system application outside the repository; no machine installer command is presented as a project-terminal step. The permission badge shows the effective value and VS Code scope AtlasMind actually read, and settings are re-synchronised before every dashboard snapshot.

• Queue exactly the code you intend to test. The Runner view names the trusted branch in plain language, recognises GitHub's pending as well as queued state, and shows the local and waiting SHAs when they differ. Complete queue and stale-run cancellation commands have Copy and Send-to-Terminal controls; Send works with the configured VS Code shell on Windows, macOS, or Linux and does not press Enter. A queue check is retryable, while one correct run plus any stale run is refused: GitHub could assign either job that shares the runner label.

• See the hardware and repository shape behind a run. Machine inspection now reports GPU identity and trustworthy VRAM readings alongside Docker's advertised GPU runtime, while keeping container GPU access off by policy. The package view maps declared Node workspaces or a bounded first-level manifest scan, highlights current-worktree impact, and inventories package formats, lockfiles, dependency monitors, image pinning and artifacts. Registry configuration values are never read and external registry metrics are shown only after a real provider adapter exists.

• Operate trusted local CI from the Pipeline dashboard. A provider-aware runner command centre now inspects host and Docker capacity, preserves at least 25% for the desktop, applies CPU/memory/process limits, and shows the calculation before execution. It can lend the machine to one already-queued, owner-authored GitHub Actions run for the current trusted commit; it never dispatches or reruns CI. The runner is an ephemeral Linux container with no host mounts, Docker socket, GPU, persistent volume, repository secrets or OIDC permission. Machine-scoped settings choose the workflow, branch, unique architecture label, immutable image, resource caps, and whether Docker Desktop is kept open, closed only when AtlasMind opened it, or always closed when no unrelated container is running. Linux-container evidence remains visibly distinct from native Windows/macOS evidence, while provider cards reserve the integration boundary for Buildkite, Semaphore and other executors.

• Run the complete quality workflow locally without exposing a workstation as a public runner. The new local-CI runbook covers compilation, lint, tests, coverage, packaging and full-history secret scanning, states exactly what a local pass cannot prove, and defines four explicit execution postures: direct local, protected trusted-branch, ephemeral/JIT, and provider-hosted PRs. A public repository may use a dedicated self-hosted runner for reviewed branch code; untrusted PR code and personal credentials remain outside that boundary. npm run ci:local:quick handles iteration and npm run ci:local runs the complete pre-push gate. Hosted matrix jobs now run automatically only on release PRs into main; an owner-only develop push/manual workflow targets an ephemeral Linux runner in Docker Desktop's isolated WSL2 VM.

• Replies stream faster, and long chats no longer get slower. Every streamed chunk used to rebuild the panel's entire state — re-reading your credential store, the checkpoint store and the run history from disk, and re-sending the whole transcript. That cost scaled with reply length and chat size rather than with the question, which is why short asks could still feel slow. Measured on one 200-chunk reply, the credential-store enumeration alone dropped from 203 reads to 3. Switching editor tabs did the same work on every click, and now does none of it.

• A project run checks it has somewhere to run. With no folder open it stops and says so. With an empty folder it shows you the plan and asks first, naming both things that could mean — a new project starting here, or the wrong folder being open. Previously it planned against nothing and ran anyway.

• Click a file path in a reply to open it. Paths are recognised however the model writes them, and a :12 or #L12 anchor takes you to the line. A path outside the workspace is refused and says so. Previously these either did nothing when clicked or drew with a line through them, as though the file had been deleted.

• Dictate a message. A microphone in the composer, transcribed on your own machine — inserted for you to read, never sent automatically.

• Restore the files a turn changed, from that turn in the transcript. Files only — the conversation stays as it is.

• Edit a message and re-run it, or regenerate a reply. Both rewind the conversation to that point, and both say how many messages that discards first.

• Rename a chat, and search across all of them. Titles are editable in the session list, and searching now surfaces matches from your other chats with the text around each one.

• See how full the context is. A bar above the composer showing what your next message carries, against the answering model's real window — or your session budget when no model is known yet.

• Pin the model when you want to. Leave it on Auto and the router chooses per task, or pin one for the next message or the whole chat. The footer still says which model actually answered.

• The composer completes as you type. / opens the command list, @ searches your workspace for a file — and picking one attaches it, not just its name.

• Attach what you are looking at. Add the current editor selection, or the Problems panel, straight to a chat turn — labelled with the file and line range, or counted by severity.

• Code blocks reach the editor. Insert at the cursor, open as a new file, or apply with a diff preview that shows exactly what would change before you confirm. Nothing is merged for you and every edit is undoable.

• Code blocks in chat are syntax highlighted, in about forty languages, using your editor's own theme colours so a snippet in chat matches the same code in the file beside it.

• The chat transcript stops rebuilding itself while an answer streams. It used to redraw the whole conversation on every chunk, which lost any text you had selected, slowed down as the thread grew, and made screen readers re-announce everything. The model badge is also keyboard-reachable now, and the spinners respect reduce-motion.

• Secrets are stripped from what chat sends. Terminal output, attached files and pasted text were the three paths that reached a model without passing through redaction — a .env dragged onto the composer went as written. And an image that could not be attached (too large, wrong format) no longer fails silently, leaving you to read the answer as though the model had seen it.

• Deleting a chat asks first. Deleting a session, clearing a conversation or removing a message used to happen the instant you clicked, with no undo and no copy of the transcript anywhere else. All three now confirm, and say how many messages you would lose.

• Chat no longer writes to tracked files on its own. Two things used to happen silently and outlast the conversation: /buzz local wrote a workspace setting, and signalling frustration wrote a note quoting your own words into project memory. Both now ask first, and the note is shown to you in full when it is saved.

• A failed turn no longer deletes your question. A provider failing mid-turn used to remove the whole exchange from your history — your own message included — leaving a generic error banner. The failure is now recorded in the transcript with whatever had already streamed. Stop also genuinely stops the model call now, instead of being noticed once it had finished.

• The two chat surfaces really do behave the same now. VS Code's @atlas view answered ordinary messages by a separate internal route that had quietly lost conversation recall, roadmap status, image attachment, and the model-and-cost footer — all of which the AtlasMind chat panel had. Both surfaces now enter through one dispatcher.

• Ask what you said, get what you said. "What was my question two turns ago?" was answered by a model guessing — and it returned a question you never asked. It now comes from the transcript, quoted exactly.

• A busy GPU no longer ends the turn. A local runtime refusing for capacity was counted as a failed model, burning the failover budget on refusals from the same card. It is not a failure, and the rest of that runtime's models are now skipped for the turn.

• The assistant can ask for a tool it wasn't given. Only a couple of dozen tools fit in a turn, so AtlasMind guesses which ones your request needs — and when the guess was wrong the assistant quietly worked around the gap. It can now ask for what it needs, limited to what your agent may already use and still subject to every approval.

  The approved Chat reliability and capability broker plan evolves this into model-budget-aware heuristic preloading, deferred discovery, and explicit one-turn elevation without sending every schema on every request.

• Turning a subscription agent off actually turns it off. The Models tree could say "model disabled" while every turn still routed to it, surviving a reload — the switch touched the agent's base entry while routing used one of its model-and-effort variants. Switching it off now stops every variant.

• "If you want, I can…" is now something you can click. Buttons only appeared when a reply ended in a question mark, and against a real model that turned out to be almost never — four turns in a row closed with offers phrased as statements, leaving nothing to click. Advice that opens the same way still doesn't, because it is telling you what to do rather than offering to do it.

• Chat can change a setting you ask it to change — behind a dialog naming the setting and both values, only for settings AtlasMind declares, written where a reviewer will see it. It also notices when a setting is wrong for the work in front of it and suggests the value, rather than changing anything.

• Chat knows what AtlasMind is, and can take you there. Ask where a setting lives and you used to get prose you then had to go and find — and it was recall, not a lookup, because nothing had ever told the model what pages AtlasMind has. It can now open the page and scroll to the card that answers your question, and it says when it is unsure of a name rather than telling you the setting does not exist.

• The footer says what the turn cost, reading through an MCP server no longer prompts as loudly as deleting a file, /Cost and /runs? are commands rather than questions for a model, the closing question is asked once instead of twice, and "use Playwright instead" keeps its context.

• A full stop inside a filename no longer deletes the question. "Want me to update README.md?" reached you as nothing at all — no buttons, no follow-up prompt. The extractor could not read past a full stop, saw md?, and judged it too short to be a question; every offer naming a file, a path or a version went the same way. Turns ending in two questions now surface both, and a long option is shortened onto its button rather than the buttons disappearing.

• A turn that is waiting on you now says so. Chat could stop before a project run and tell you nothing, and typing "continue" would then start one. Any offer to do work now shows a decision card — it no longer has to say the words "project run" — and the card no longer deletes the question it is about. Runs also state their goal before doing anything.

• A project run is planned against the work, not the word you agreed with. Saying "yes" to an offer that ended "Shall I go ahead?" started a run whose goal was literally go ahead — plan, file estimate and cost all derived from that fragment, which is why such runs read as coming from nowhere. And if AtlasMind said it was waiting on you, "continue" no longer overrides that.

• Reacting to how you sound no longer changes your settings. If AtlasMind decided you were frustrated, it quietly raised two chat settings in your workspace — into .vscode/settings.json, which most projects commit — and said nothing about it. It also mistook ordinary polite requests for frustration, so this happened on turns where nothing had gone wrong. That path is gone, earlier values are restored, and it is now much better at noticing when you genuinely are unhappy.

• A good answer is no longer thrown away because a tool read a file. When a step's tool results all looked like failures, AtlasMind replaced the assistant's answer with a failure dump and marked the turn an error — and "looked like a failure" was any output containing words like failed or cannot, which file contents routinely do. The answer is kept now, with the failure reported underneath it, and the error mark is reserved for a turn that produced nothing. That mark also fed model and agent scoring, so the mistake used to outlive the conversation it happened in.

• The chat window now has a stress battery held to a higher bar than the code. 57 probes across ten lanes ask whether chat does right by the person reading it — does a question it asks reach you as something you can answer, does the answer arrive whole, does a turn that stops waiting say so, can it reach the product it is part of. It lives in evals/ and runs from its own config, because its failures are findings about the shipped surface rather than regressions.

• Your governance regimes are now checked against your stack. ISO 27001, SOC 2, NIST 800-53 and AI safety are mostly human judgement — but "a backup is taken before a production promotion", "no endpoint uses plaintext http", "dependencies are scanned", "changes are reviewed before merge" are facts about a stack, and AtlasMind already knows all of them. 26 controls are now verified automatically, each with its evidence and the rule behind it, and the ones still needing a person are counted separately so "4 of 7 verified" is never mistaken for the whole regime. A signal nobody gathered reads not assessed, never a pass.

• Scaffold picks the test runner your project actually uses. It now detects Vitest, Jest, Mocha, the Node built-in runner, Playwright and Cypress from your dependencies, config, scripts and test files — and generates starter tests in that runner's syntax rather than always in Vitest's. What you already use always wins; where the choice is genuinely open it asks rather than guessing; and it will never add a second runner to a project that already has one.

• Both Testing surfaces list every framework installed, not just the first one matched — a project with a unit runner and a browser runner has two, and naming one implied the other was missing.

• A filter above the methodology matrix, because sixty-nine rows is more than anyone scans.

• ISO 27001 and SOC 2 ship with a control mapping — including the governance half. Both regimes were declared as engineering checklists (ISO had nine technological controls and one organisational; SOC 2 had no CC1–CC5 at all). They now cover all four ISO themes and CC1–CC9, grouped so the organisational half is the first thing you see, with the controls AtlasMind can verify pointing at the live result rather than copying a verdict into a file that is never rewritten.

• Statistics on the Testing dashboard, so protocol state reads at a glance: where the test cases actually are, evidence by category, a governance-control breakdown, and a status strip on every card.

• The dashboard fits your window. Grids now reflow on a stated minimum instead of dividing the width by a fixed column count, the page is capped and centred, and prose stops at a readable measure. Testing policy cards are wider, and an expanded one takes the full row.

• Compliance could read as met on evidence that proved nothing. ISO 27001 counted a SECURITY.md — a file saying where to email a bug — as evidence of the certification, and a scaffolded control mapping counted before anyone had filled a single row in. Both are fixed: only the control mapping counts, and only once a control has actually been assessed. An unevidenced gap is a prompt to do the work; a false pass is something somebody repeats to an auditor.

• Three testing policies could never read as covered. dead-field, dependency-graph and explainability had marker patterns that no test file could ever match, so each stayed a gap however much work was done — the thing that teaches people to stop trusting a board. All three now match a test named after them, and two invariants keep it that way.

• Every file-evidenced testing policy now has a real test behind it, not a scaffolded placeholder. A placeholder counts as evidence on the dashboard while asserting nothing about your code, which is worse than an honest gap. AtlasMind's own 27 enabled policies are now evidenced against the modules that own each property.

• Your testing policies now react to your code. Coverage used to be a yes/no per methodology — does anything here test contracts? So one contract test written in March still reported "Tested" in December, after forty endpoints had been added.

  AtlasMind now reads what your project actually declares — API paths, GraphQL operations, gRPC methods, migrations, schemas, routes, roles, prompt files — and each becomes something its policy has to cover. Add an endpoint and the obligation exists from that moment; you never write a rule. Uncovered items are listed on the policy card with a link to where each was declared, and the agent doing the work is told the specific item rather than just the methodology name.

  A test counts when it names the thing it covers, method included — a GET test says nothing about the POST. Only declared artifacts count: nothing is guessed from your source, because inventing obligations is worse than missing one.

• Testing policy cards open up. Each enabled policy on the Testing dashboard is now clickable. It expands to show what the evidence actually is — a chart of passing, skipped and failing cases, a table of the evidence found, and the failing cases with a link to each file. Every finding carries a severity graded by a published rule you can read on the page, so a grade given today means the same as one given last month.

  From the card you can assign an owner (unassigned work falls back to you, and says so), add it to that person's follow-ups with a due date matched to how bad it is, and — for a serious finding — draft a GitHub issue. The issue is always shown before anything is posted; severity decides what gets emphasised, never what gets filed. A policy you switched on but have not built yet gets its own Scaffold framework button, which lists the exact files before creating any.

  The page now leads with Needs attention, Open gaps and Unowned rather than file counts — "43 test files" reads the same whether or not three are failing and nobody owns the gap.

• The Scaffold framework button is now verified end to end. Checking it turned up five real faults: a starter file that did not parse, a Command Palette path that skipped the AI-instruction sync, two buttons wired twice so one click ran everything twice, an Auto-assess button left dead after you cancelled its dialog, and a strategy playbook that under-reported the files it had just created. All fixed, and all now covered by tests that parse every file the button writes.

• Auto-assess now reads your code, not your README. It used to match every signal word against one blob of text that included three kilobytes of your README — so a project got testing methodologies because of what its own description said about it. On this repository that was twelve policies fired by prose alone, including PCI-DSS and bias & fairness on a VS Code extension that handles neither. It also matched words inside other words, so "rapid" switched on integration testing.

  Now a signal found in your code — a dependency, a script, a config file, a directory that exists — ticks the policy and says what it found. A signal found only in your description raises it as a proposal, unticked, saying which words prompted it. Nothing is hidden and nothing is more than one keystroke away; auto-assess just stops making the decision for you. Dependencies are read from every manifest now, not only package.json, so Python, Rust, Go, Java and .NET projects get a real assessment instead of one based almost entirely on their README.

• The testing matrix grew from 23 methodologies to 69. Five new families: drift and integrity checks over your code's own shape, parity and consistency across surfaces and versions, data and schema testing, AI-specific testing (prompt regression, guardrails, model routing, hallucination detection), and twenty-four compliance policies covering security and privacy, operational process, software supply chain, AI governance, and five industry regimes. Each one arrives complete — a plain-language explanation, evidence detection, a place in the archetype recommendations, and a starter file the scaffolder can add to a new or existing project.

• Compliance policies scaffold a control mapping, not a fake test. Most of a compliance regime has no assertion behind it — "cryptography is governed by a policy" is not something a test can check, and a stub written for it can never honestly pass or fail. Those policies get a control mapping instead: control, status, evidence, owner, in project_memory/operations/compliance/. Controls a machine can check — role permissions, audit trails, retention windows, erasure reaching every store, SBOM accuracy, licence policy — still get a real test. Every row starts at Not assessed, never at a pass, and the file is never rewritten once you have put decisions in it.

• A failed promotion step can now be handed straight to Atlas. Promoting to production and having the tests fail used to leave you with a wall of output and no next move. Each failed step now carries Ask Atlas to fix this — it opens a new chat with the step, its command and its output, secrets redacted. Atlas proposes the fix; it will not re-run the promotion, because that gate is yours.

• AtlasMind tidies up after itself on a full card. It now releases models it loaded to make room for the next one — never a model you loaded by hand, never one in use, and never half-way (if clearing everything available still wouldn't fit, it waits instead of costing you the reloads).

• Local models no longer fight over your graphics card. If you run Ollama and LM Studio, they each decide what fits without knowing the other exists — and neither leaves room for your desktop. On a 24 GB card with no model loaded at all, Windows and a browser were already using 9.2 GB. AtlasMind now measures what's actually free before sending a local request, queues what won't fit, and moves the turn to another provider rather than over-filling the card. A model you loaded by hand is never unloaded.

• A timed-out local model is now actually stopped. When a local request ran past its deadline AtlasMind gave up waiting but never told the model to stop, so it carried on generating — holding your GPU and its memory for an answer nobody would ever read, while the retry queued up behind it.

• A turn no longer fails on models that were never going to answer. Your provider's model list is an inventory of everything it serves, and most of it can't chat — embedding models, rerankers, Whisper, safety classifiers. AtlasMind treated them all as chat models. Local ones are free, so they looked like the best option exactly when everything else had failed, and a safety classifier cannot answer a question at all. They are now recognised by family and kept out of routing entirely.

• AtlasMind waits long enough for the model to answer. A local 14B model loading its weights and reading a long prompt was being called a timeout at 30 seconds — a limit written for a hosted API call — then dropped as unhealthy while it was working. The wait now scales with the model's size, your prompt, and whether the model has already answered once this session. Subscription agents get room for the process start and handshake that happen before your prompt is even seen.

• When a turn fails, you're told what failed. The old message led with the limit it hit and quoted one error from the last model tried. You now get every model attempted, what happened to each, and how long it took — and if everything timed out, it says plainly that nothing reported a fault, so this is an endpoint not answering rather than a model at fault.

• Chat can do GitHub work. gh was missing from the terminal allow-list, so asking about issues, pull requests or CI hit a refusal you never saw — the error went to the model, not to you, and looked from the outside like AtlasMind losing interest. GitHub questions now also get tools that can actually reach GitHub, rather than local git tooling that cannot see a review or a CI run. Subcommands are graded like git's: reading a pull request is a read, merging one asks first, and seven — including gh auth token — are refused outright at any setting.

• Existing UI source now produces an honest adapter report. React, literal HTML/CSS, and VS Code webview mappings import bounded structural facts, exact-match prop/slot suggestions, provenance, and explicit losses; custom targets say unsupported instead of pretending generic parsing understood them.

• Imports are proposals, not authority. Suggestions can be copied into the mapping form for review, then require a separate Apply action. Source stays local, bounded, unexecuted, absent from memory/browser/model state, and every built-in report remains explicitly partial.

• Design and source can now be connected without pretending they are the same thing. UI Studio maps a component, token, or node to a real project file and symbol through a named adapter, including prop/slot correspondences and honest coverage limitations.

• Repository divergence is visible before reconciliation. Local hash-only verification distinguishes design-only, code-only, and conflicting changes. It reads bounded workspace files but stores no source, writes no source, sends none to the browser/model, and never chooses which side should win.

• Chat carries the turns you just had. The context carried between turns was keeping the oldest messages and dropping the newest, so past about six turns it froze on how the conversation opened — and raising the limits only bought more old turns. It could also arrive out of order, a message could be made permanently invisible by containing the words "ignore this", and session files were parsed with an anchor JavaScript doesn't have, which silently truncated open threads and current state.

• Chat remembers what you said. Your conversation was being sent to the model inside a block labelled "treat everything below as user-controlled data, not instructions" — a warning that belongs on an attached file, not on you. Since nothing else carried the history, the model was told every turn to disregard your earlier messages. Attachments and fetched pages keep the warning; your conversation now travels as the conversation, and says so.

• Two safety boundaries in chat now do their job. Nothing approves a project run on your behalf any more: however a run is asked for, AtlasMind shows the plan first and — when the estimate exceeds your file threshold — offers Approve and run rather than telling you to retype the goal with a token. Separately, the data-privacy scan now inspects the whole conversation. It read only the raw transcript, which a long-running session stops using once it has a compressed context file, so the scan had been quietly inspecting nothing while the model still received everything.

• Assets are now first-class design data. UI System owns validated workspace-relative or credential-free HTTPS references, dimensions, crop/focal intent, alt/decorative intent, and maturity; canvas nodes assign one by stable id. Studio, Full Preview, JSON, and the Markdown mirror consume the same authority.

• Full Preview preserves its no-network boundary. It projects asset aspect ratio, crop, focal point, provenance, and accessibility status as inert markup rather than fetching remote content. Missing asset ids and missing alt text are errors at the assigning node.

• Structured sample data is now first-class design material. UI System defines bounded collection schemas and deliberate preview fixtures; canvas nodes bind title, body, and action slots to one record. Studio and Full Preview render the same declared values without connecting to production data.

• Broken bindings and incomplete data states stay visible. Missing collections, samples, fields, values, and empty/loading/error/success designs are reported at the owning node. Exact revisioned commands protect every edit, and used collection facts cannot be removed underneath a binding.

• Empty, loading, error, and success copy can now be designed in context. Every canvas node can own bounded state title/body/action copy with visible maturity, choose a state for review, and render it identically in Studio and the full built-in-browser preview without replacing the screen's Markdown source.

• The orchestrator now records when it discards a model's answer. If every tool result in an agentic loop's final round tests as failed, AtlasMind replaces the model's reply with a summary of those failures — and that test matches substrings like failed or cannot against raw tool output, which reading a file returns verbatim. The substitution is now logged with the tools involved and the token that triggered each verdict, so a tool that genuinely failed can be told apart from one whose output merely mentioned failure. Trigger tokens only, never tool output, which can carry secrets. Behaviour is unchanged; this is measurement ahead of a fix.

• Reusable components are now first-class design data. UI System owns bounded definitions with typed properties, variants, slots, and interaction states; the canvas inspector creates explicit instances and keeps per-instance overrides separate. Studio and the full built-in-browser preview show the same result.

• Typed design tokens are now directly editable and visible in both review surfaces. UI System can add, update, alias, and delete bounded tokens through the same revision/undo history as canvas edits. Reserved semantic tokens drive the Studio canvas and Full Preview, while adapters expose every resolved definition.

• Phase 3 starts with typed design tokens in the authoritative graph. Colour, typography, spacing, radius, shadow, motion, and breakpoint values now have bounded target-independent definitions. Aliases propagate deterministically and are refused when missing, cyclic, or linked across token kinds.

• Responsive diagnostics now complete the layout loop. Desktop, tablet, and mobile each report viewport overflow, parent clipping, unintended overlap, and undersized 44px touch targets from the same projection shown in Studio and Full Preview. Click a finding to select its owning block.

• Multi-selection now supports real pointer drag. Drag any selected block to move the whole selection without changing its spacing or hierarchy. Base and responsive gestures are each one validated revision and one undo step; locked or container-positioned members keep the operation closed.

• Duplicate and lock are now safe canvas operations. Duplicate copies a selected block and its complete nested subtree as one undoable edit, preserving hierarchy and moving authored responsive rectangles too. Lock keeps a block selectable for review while the host reducer refuses every edit except Unlock.

• Stacks now wrap and container children have responsive order. A stack can continue on another row or column when its main axis fills, while a bounded order value deterministically sorts stack/grid children before placement. Both properties inherit, reset, and render identically in Studio and Full Preview.

• Responsive min/max sizing is now part of the real layout engine. Set optional width and height bounds in canvas units; free, stack, grid, overlay, fixed, fill, and hug all obey the same inherited constraints in the Studio and full built-in-browser preview. Clearing a bound recovers the retained drawn/intrinsic size.

• Stack, grid, overlay, fill, and hug now drive the actual layout. Configure direction, gap, padding, columns, alignment, and distribution in the inspector; the same deterministic projection appears in the Studio and full built-in-browser preview at desktop, tablet, and mobile. Resetting a responsive behaviour restores inheritance without losing geometry or visibility decisions.

• The Studio now has atomic multi-selection layout tools. Shift/Ctrl/Cmd-select several blocks, then align edges or centres, distribute spacing, or nudge the group at desktop, tablet, or mobile. The complete transform is one validated revision and one undo step; it never changes hierarchy or broadens deletion.

• Responsive layouts now support direct manipulation. At tablet or mobile, drag, resize, or use the arrow keys to turn the inherited rectangle into a deliberate breakpoint override. Drawing, deletion, and nesting remain base-only, so responsive work cannot accidentally change the shared structure.

• Responsive design is now inspectable and editable in the Studio. Switch the canvas among desktop, tablet, and mobile; select even a hidden node; see exactly which breakpoint supplied its geometry, visibility, layout mode, and sizing; then apply or independently reset tablet/mobile layout and visibility through the same revisioned undo/redo path as other canvas edits.

• Full Preview now reflects responsive design intent. The deterministic Studio draft projects inherited tablet and mobile geometry/visibility as the built-in browser or Responsive lab changes width. The result remains static, script-free renderer output with content and style together; only AtlasMind's existing frozen live-reload/selection runtime is injected by the host.

• Responsive layout now has a deterministic inheritance engine. Desktop values flow through tablet into mobile, each computed property reports whether it came from the base or a named override, and clearing an override restores the inherited result. Setting and clearing responsive geometry/visibility uses the same exact revisioned, undoable command boundary as direct canvas editing.

• The UI Studio foundation is proven across three kinds of product. Committed executable fixtures for a marketing website, data-rich web app, and native desktop UI now verify lossless migration and reopening, the shared edit/history/selection contract, deterministic full-browser content previews, and the absence of target technology or website-delivery fields from the authoritative graph.

• Canvas edits now use the authoritative revisioned graph. Drawing, moving, resizing, nesting, deleting, changing kind, label, or design intent, plus undo/redo, all pass through one exact command parser and pure reducer. Each accepted gesture advances revision once; stale or invalid gestures restore host-owned state, and Save can no longer replace the graph with an arbitrary webview payload.

• The Studio canvas and full browser preview now share selection. Selecting a saved block in either surface highlights and focuses the same graph node in the other. The browser can submit only the current render revision plus bounded screen/node IDs; the host resolves those IDs against the saved graph, and stale, malformed, oversized, extra-field, or wrong-token requests are refused.

• The full browser preview now follows saved design and content changes live. A frozen Studio-only runtime listens for revision numbers on the token-protected loopback server and reloads when the deterministic draft changes. It cannot submit edits, graph fragments, paths, commands, or source code; generated/exported output remains independent.

• UI Studio now has a durable plan to compete as a complete visual builder. The repository records the product contract, delivery phases, acceptance criteria, reference projects, quality measures, and the design/source/preview authority decisions. See the full builder plan.

• The visual design now has one revisioned graph underneath it. Format v6 preserves every existing wireframe fact while giving screens and nodes stable identities, bounded layout, responsive override slots, and content/style/component references. Existing renderers receive a derived compatibility wireframe, so this foundation can land without disconnecting today's Studio.

• Future canvas and preview edits now share a safe mutation protocol. A pure closed command reducer checks the graph revision, node, geometry, and parent relationship before changing anything. Undo and redo restore design content while revisions keep moving forward, so an old browser or webview event never becomes current again by accident.

• Preview is now the centre of UI Studio's design loop. Full-canvas review opens in VS Code's built-in browser and always starts from a deterministic index built from saved structure, visual tokens, and exact Markdown content. Content gaps remain visibly unfinished, all copy appears again in a complete content proof, model-generated output stays linked but separate, and the guarded companion view remains available for desktop/tablet/mobile inspection.

• Website Studio has become UI Studio. Choose a website, web app, mobile app, desktop app, editor extension, embedded UI, or another interface profile. Non-web projects use screens, flows, content, wireframes, design tokens, components, and a technology/source-location handoff without being forced through HTML, SEO, hosting, or n8n concepts. Any profile may render an implementation-independent HTML visual guide; website projects additionally keep the delivery tools intact.

• Content is now designed beside the interface. Project voice, principles, terminology, reading level, locales, and accessibility notes live in the reviewable SSOT. Each screen also has a real Markdown content editor for headings, labels, instructions, empty/loading/error/success states, and recovery copy. Missing files can be seeded with explicit placeholders only; concurrent disk edits are refused rather than overwritten.

• Branch Dashboard choices now stay chosen. Saved view, sort, order, grouping, and SCM-colour preferences survive closing and reopening the dashboard for this workspace. Recent activity also reflects the newest commit across a folded local/upstream pair, keeping newest-first and oldest-first ordering faithful when the two refs differ.

• Project Director now carries the same live attention signal as Project State. Active dashboard work assigned to your Director identity joins due and overdue reminders under Follow-ups. The Project Director title, Follow-ups row, and AtlasMind activity icon all carry the same count—even while the view is collapsed.

• Sidebar ToDos now open the record they name. Dashboard links carry a validated page, work kind, and stable item id. The dashboard opens the owning page, clears any presentation filter hiding the target, scrolls it into view, and gives it a visible focus outline. Director's Open work links use the same route; removed or not-yet-loaded records still fall back safely to the correct page.

• A closed Project State panel still tells you what is waiting. Its live title now reads Project State · N waiting, so collapsing the ToDo list no longer removes the only local indicator.

• Project State carries its attention count on all three visible surfaces. AtlasMind's activity-bar logo keeps the container badge, the open Project State header says how many items are waiting, and Waiting on you carries a coloured numeric row badge instead of an unstyled trailing number.

• Your assigned work now reaches Project State. Choosing your own Director identity on a branch, roadmap item, issue, pull request, gap, risk, debt item, document, or run adds that active work under Waiting on you immediately. The same count badges the Project State title and AtlasMind activity icon, while completed, cancelled, and other people's work stay quiet.

• Branch Work actions are compact and resilient. The owner picker and icon toolbar now share one flexible content column, so narrow cards no longer squeeze action labels into vertical word stacks. Each icon keeps the complete action and safety explanation in its tooltip and accessible label.

• Branch cards now carry the daily workflow. Expand any card to work on that branch, prepare a commit in Source Control, pull with a fast-forward-only guard, push or publish without force, create a new local branch from its current commit, and open GitHub's pull-request form. Each action sends only an opaque card id to the extension host, which rebuilds live Git state before it enables or runs anything; merge, rebase, force-push, and automatic commit remain deliberate workflows elsewhere.

• The Director can assign people where the work appears. Branches, roadmap items, open issues and pull requests, gaps, risks, debt, and documents needing attention now expose the same owner picker. Those owners are stored once in Project Director; its Assignments view lists active work so an owner can be assigned there first or changed later. Each work page and the people view therefore report the same responsibility.

• Resolve & run now prepares the release as one operation. The Detected Runbook names version preparation explicitly. When a promotion needs a bump, AtlasMind updates the manifest, npm lockfile, formal changelog, and recognised README/wiki version markers together before committing, so the repository's own pre-commit checks do not reject a half-updated release. If a hook still fails, the dialog shows clean, concise failure-tail output instead of pages of terminal escape codes.

• The Buzz roadmap now defines AtlasMind persona teams for future implementation. Director will recommend a small set of Buzz-facing roles from the project's enabled agents, allow one AtlasMind agent to participate in several personas, and keep each signed Buzz identity behind a constrained orchestration scope. The plan separates shared project intent, local deployment state, the headless runtime manifest, and Buzz-owned keys; it also makes exclusive default routing and colleague allowlists an explicit compatibility gate rather than an assumption.

• Pipeline is now a CI control centre, not only a run history. It explains the three professional layers—workflow definition, trigger/branch assignment, and required-check enforcement—then inspects every GitHub Actions file into readable workflow and job cards. Beginners can see what runs and why; experienced engineers get runners, timeouts, permissions, concurrency, validation coverage, and delivery-gate bindings. Existing workflows can be opened or reviewed with AtlasMind. A Node project with no quality CI can preview and create a deterministic, create-only starter from its real branches, lockfile and package scripts; no YAML, command, or path comes from the browser, and no existing file is replaced.

• Workflow stages are now obvious at a glance. In Workflow → Your workflow file, enabled segments use a green outline and standard Enabled tag while disabled segments use a muted outline. Row contents and the larger marker remain neutral; the written Enabled / Disabled label means the state no longer depends on a small checkbox or on colour.

• Delivery is compact until you need it. Every detected runbook column starts collapsed, and its numbered marker is green, blue, amber or red according to the strongest status inside. Open one to see its steps; every non-green step carries the AtlasMind logo, which opens a host-resolved repair draft for that exact item.

• “Ask AtlasMind” is now one visual language everywhere. Dashboard fixes, Lens explanations, MCP setup help, UI Studio design questions, and Project Run draft refinement all use the AtlasMind logo alone. Hovering names the exact action, while aria-label text keeps the control explicit for assistive technology.

• The Delivery page now tells you how this project actually ships — and will run it for you. AtlasMind detects the runtime, package manager, lockfile, project scripts, bound delivery routine, CI/CD workflows, production target, and safety gates, then lays them out as Prerequisites → Validate → Package → Deploy → Publish. Exact repository configuration is kept distinct from standard runtime conventions and manual checks, and missing load-bearing steps are explicit blockers. This makes an unfamiliar Node, Python, Go, Rust, Java, .NET, or container project useful to a new contributor without pretending all projects deploy the same way.

  Every command has a copy icon and a send to terminal icon, and each column has a ▶ Run button for the whole phase. Refreshing the page still runs nothing. Send-to-terminal deliberately does not press Enter — it moves focus to the terminal instead, so your own keystroke stays the last gate on a single command and is the very next one available; running a column opens a confirmation that names every command in order, marks the ones that leave your machine, and says whether a failure will stop the rest — it will not on shells without &&, which is precisely the case where a failed test would otherwise be followed by a publish.

• You can finally see the wireframe. The preview was showing a white page, and the reason was structural: nothing in AtlasMind could turn a wireframe into HTML, so it could not reach a browser without first spending a model call — and before you generated, you got the server's one-line error page. Wireframes now render straight to HTML with no model involved: instant, free, identical every time. Every block is unmistakably a placeholder — hatched, dashed, labelled; a text block is grey bars rather than lorem ipsum, an image a crossed rectangle rather than a stock photo — and your nav shows the real page names from your sitemap, because those are facts rather than filler.

• Page copy lives in markdown you can hand to a copywriter. Generated sites used to be full of invented headlines and fictional testimonials, which is worse than an empty page: an empty page is obviously unfinished, and confident fiction gets signed off. Copy now lives in content/, one file per page, diffing properly in a pull request. Where the words are not written you leave a [PLACEHOLDER: what is needed] marker, which AtlasMind counts — so a page reads as "four placeholders remaining" rather than a status somebody ticked, and generation is told to leave the gaps visible rather than fill them.

• Your client can comment on the actual thing. Not "the hero is too big" in an email, leaving you to work out which hero. They open the staging site, click the element, and type; the comment lands against that element, transitions through open → addressed → resolved, and becomes scoped work with one click. Delete an element somebody commented on and the comment survives, flagged — it is the evidence the thing was removed while under review.

  AtlasMind hosts none of it. The overlay ships inside your site, so it travels to the password-protected staging environment the Stack page already sets up — your client's own hosting. Feedback comes back as a downloaded file, or by POST to an endpoint you already own. No endpoint is ever invented; without one the page cannot make a network request at all.

• Website Studio can now set the project up for you. The Platforms page became a Stack page, because the framework and the host are one decision: "Astro on Cloudflare Pages" has a known build command, a known output directory and a known deploy config, and splitting them made the compatible pairing something you had to already know. Pick from ten frameworks, each graded against your chosen platform with the reason shown — including the bad pairings, because removing Hugo when Shopify is selected just leaves you wondering where it went.

  Set up this stack then runs the framework's own create command, writes the deploy config, adds the dev/build scripts, creates a .env.example with variable names and no values, makes the develop/staging/production branches, and — if you turn it on — writes a GitHub Actions workflow that deploys each branch to its environment. Everything is shown first: every command with its purpose, every file with its full contents. Commands are constants in AtlasMind's source, run with no shell, and every file and branch step is create-only, so re-running is safe and nothing you wrote is overwritten.

  Three switches, all off by default and separate on purpose — scaffolding, generating CI, and letting AtlasMind run the hosting provider's CLI are three different decisions, and the last one spends money on your account.

  The Stack page also compares itself with the Delivery pipeline. Website Studio keeps its own three environments, so the two can drift; rather than hide that, the page shows exactly which fields disagree, and says plainly when nobody has looked yet.

• Website Studio: draw the site, point at it, and press Generate. The old wireframe was the first eight strings from a page's section list rendered as coloured blocks — no position, no size, no nesting, nothing downstream could act on it. There is now a real canvas: drag a nav, a hero, a grid or a card onto a snapping 12-column grid, resize from eight handles, drop one block inside another to nest it, and move it with the arrow keys. Every block is focusable and announces its kind, width and position, so the canvas is not mouse-only. Geometry is stored on a fixed 1000-unit grid rather than in pixels — website.json is committed, and pixels would record the author's monitor size.

  The sitemap now draws its own hierarchy, derived from the slug path as pages are added, so /services/seo appears under Services without anybody drawing an edge. An explicit parent overrides it. A page whose slug names a parent that isn't there is shown at the top level and flagged, rather than hidden or silently re-parented — and the map is deterministic, so it never shifts when nothing changed.

  The page inventory knows where each page leads — outbound links, inbound counts, orphan pages, and links whose target was deleted. A broken link is kept and marked rather than tidied away; it is the evidence that a nav is broken.

  Select anything and describe it in plain English. Click a hero, type "full-bleed photo, headline left, one button", and Atlas gets a prompt naming the selection completely — kind, label, width, what contains it, which page, and the shared design tokens. That is what makes "make this wider" answerable. Works for a page and the whole site too. Every page can also carry its own written design prompt, so a site can reach first-draft design from the sitemap alone without a box being drawn.

  Generate works from wherever you are — brief, sitemap, a wireframe, or one selected element — and its result remains linked from the full built-in-browser preview. The file list is decided before any model runs, so the confirmation dialog names every file you are agreeing to. Both switches are off by default, and they are two switches because writing files and opening a port are different decisions. Files land only in .atlasmind/website-preview/, never in your source tree; the preview server binds 127.0.0.1 only and stops through Stop Preview, Studio disposal, or extension deactivation.

• Every panel now looks like the Project Dashboard. Settings, MCP, Model Providers, Agent Manager, Mission Control, Run Center, Cost Dashboard, Model Comparison, UI Studio, Ideation, Vision, Voice, Specialists, Tool Webhooks, Skill Scanner, Chat and the ten Lens surfaces draw the same card, the same header, the same tab and the same input.

  The reason they didn't is structural. Each webview is an isolated document, so a panel genuinely cannot inherit another panel's stylesheet — which over time produced nineteen palettes under five prefixes, four of them drifted copies of the dashboard's. There is now one definition, applied in two layers: tokens and the page frame before a panel's own CSS, surfaces after it. A panel keeps its layout, which it owns, and loses its private palette, which it never chose.

  Colour that carries meaning is left alone — the Ideation board's tinted notes, the chat transcript, warnings, and each Lens's own accent. The Personality Profile is unchanged by request.

• The Pipeline page can read CI itself, and says when it couldn't. CI was only ever fetched as a side effect of the Issues refresh, so the one page whose whole subject is did the build pass had no way to go and find out — its empty state sent you to a different tab. It now has its own Refresh CI, two gh calls rather than five. And an empty run list no longer reads as a quiet green: "this branch has never been built" and "we could not ask" are now told apart, with the reason and the command that fixes it.

  The CI pass rate on the Workflow page also stopped abstaining. It was wired to an empty array left over from an earlier phase, so it reported not measured however many runs were sitting in memory. It now derives from the checks on the head commit — deliberately just that commit, since a fortnight of branch history would have made a clean commit read red for failures somebody already fixed.

• Connect a database directly — Neon, Supabase, RDS, Railway, self-hosted, MySQL. The live lenses originally reached a database only through an MCP server, which meant most people were told to install one before they could use the feature. Now you point AtlasMind at a postgres, mysql or sql-http endpoint, store the connection string in the OS keychain with AtlasMind: Store a Live Service Credential, and it reads the catalog directly. The string never touches your repository — the committed file names the key, and a file containing an actual credential is refused outright.

  It also measures: row counts, table and index sizes, constraints, how stale the statistics are, connection latency with cold starts called out separately, and the query plan. Every number comes from the catalog the database already maintains — no COUNT(*), no table scan, no row of your data read to produce any of it. A table nobody has analyzed reports unknown, never zero, because "this table is empty" is the most expensive thing it could get wrong.

• The lenses can now look at the services your project actually talks to. Every lens read the repository, so the question people really have — does the running system still agree with what the code believes? — was one AtlasMind could not answer. Three new lenses close that. Live Contract Drift compares the schema you declare against the one a live API or database serves, and names every field that has gone missing, changed type, or turned up without being declared. Service Reachability reports which declared services answered, which did not, and which nobody has looked at. Live Data Trust lists the fields a service actually serves that no classification covers.

  It reads shape only — the schema a service publishes, or a listing of tables and columns. Never a row, never a field value, never a write. Which services may be reached is declared in a committed file that names a stored secret rather than holding one, and Atlas will not draft that file: a hostname nobody typed is a request to a stranger made in your name. Probing is off by default, production is not in the default allowed stages, and an endpoint that does not say which environment it is gets treated as production and asks you to type its name before every probe.

• "Promote to staging" now means what your project says it means. AtlasMind records your delivery pipeline — the stages, what each one is called, which branch represents it — and until now the chat side never read it. Ask to promote to staging and it would go looking for a branch called staging, fail to find one, and ask you which branch you meant, while the answer sat in a file it wrote itself. It now reads that file first, and a stage's kind counts as a name, so "staging" finds the stage whose kind is staging whatever you happened to call it. It will not invent a stage you never declared.

• A request to merge now arrives with the tools to merge. Tool selection worked word by word, so "merge to main then publish" was given the three tools that describe a repository and none of the tools that change one — and a model handed that set writes a confident report instead of stopping. Merging, rebasing, cherry-picking and promoting now get the write tools as a set. Asking a question about a commit still does not hand over the ability to publish one.

• A failing model provider costs you less. When a subscription agent crashes mid-turn, AtlasMind no longer walks back into the same broken process with a different model name, no longer spends the budget it needs for recovery on an optional quality upgrade, and no longer opens the next message with the endpoint that just failed twice. When it does give up, it tells you which limit it hit rather than blaming a ceiling it never reached.

• Large tool sets no longer flood the context. Agents set to use every skill were sending every tool schema on every query, including every connected MCP tool. There is now a per-turn ceiling for all agents, and when it trims something it says so — a silent cut reads as "this is everything I have".

• The Lens declaration files now come with a guide instead of a blank page. Two of the eight lenses read a file you have to write yourself, and until now the help on offer was an empty {"version": 1, "machines": []} and the advice to use schema autocomplete — which only helps if you already know both what the format means and what your own project's state machines are. AtlasMind: Lens: Declaration Guide (also /lens, also every "Show me how" button on the Lenses dashboard) says what each file is for, shows a worked example small enough to read, and can ask Atlas to read your repository and propose a first draft.

  A draft is a proposal, never a write. It goes through the same check the lens itself reads the file with and is refused whole if it fails, rather than being patched up. Every file path it claims is verified against your workspace and dropped if it does not resolve, because a link that goes nowhere is worse than no link. Any value that looks like a credential is left out of the file entirely — these files get committed. You see the result in full, with every correction listed, before anything is written, and existing entries always win over drafted ones.

  Two more declaration files, lens-mappings.json and lens-data-trust.json, are now visible too — as optional refinements that are never counted against you.

• Atlas Lenses has a front door. AtlasMind: Lens: Open Atlas Lenses Dashboard opens one page for all eight lenses: what each one reads, the question it answers, whether it can answer it right now, and why not. A flow map draws the links between evidence, lens and question, and hovering any card follows its connections. Every lens, evidence source and suggested action is clickable, and a ⓘ on each explains it in plain language — including what that lens cannot prove. A Do this next band lists only what needs a person, and is empty when nothing does. Opening it runs no model and writes no file.

• The eight Lens surfaces now look like one product. Possible Flow, Change Impact, Test Evidence, State Lifecycle, Configuration Resolution, Change Story and Field Wiring were written weeks apart and looked it. Relationships that used to be listed as text are now drawn: state transitions curve between the states they connect, impact links point into a symbol from its callers and out of it to its callees, and a configuration chain shows which source the value actually reaches.

• The README and the whole wiki have been rewritten for people, not maintainers. Every page now opens by saying what the feature is, who it's for, and what it does for you, before it gets into detail. The stale competitor comparison table is gone for good — it made claims about other people's software that nobody was keeping true.

• The reader-facing docs now agree with the runtime. wiki/Home.md says 27 built-in agents, the Remote Control page names the gateway enable command, and its safety copy no longer contradicts the settings table.

Recently shipped

Highlights from the last few releases. Everything here is already in the published build.

• One request now finishes in one turn. Ask AtlasMind to commit, push, promote or publish and it follows your project's declared route without stopping to ask you to repeat yourself. Approvals and release gates are unchanged.
• Branches became a decision dashboard. Every branch shows a plain verdict — Ready for review, Needs attention, Blocked — built from real pull request, review, CI and roadmap evidence. Compare any two branches, see who owns the changed code, and clean up merged branches through a guarded queue that never force-deletes.
• Your subscription agents can do real work. Claude Code, Codex and friends can now be given tool access for a task, with each operation logged. Off by default; one clearly-labelled switch turns it on.
• Research scans that look outside your repository. Seven questions — competition, customers, technology, feature gaps, market, funding, regulation — recorded as evidence your ideation board can use. Every finding carries a source, or it isn't recorded as a finding.
• Testing stopped being a checkbox. The methodologies you enable are now told to the agent writing the code, checked against what's actually in your repository, and counted in your project score — with an honest "nobody has looked yet" instead of a fake pass.

What's included

Make it work the way you do

The Personality Profile shapes Atlas's role, tone, reasoning style, memory habits and boundaries. Save a global baseline, then override it per project when a repository needs something different.

Settings → Agents shows the guardrails that apply to every agent, and opens the Agent Manager where you can review the built-in agents or create your own with their own instructions, tools, models, budget and testing role.

More in Agents and Skills.

Chat commands

Type these in the AtlasMind chat panel as /<command>, or in the VS Code chat view as @atlas /<command>.

Full behaviour and the Command Palette list are in Chat Commands.

A few settings worth knowing

Everything is in the AtlasMind Settings panel, or under atlasmind.* in VS Code settings.

All 142 settings are documented in the Configuration reference.

Where things live

The full service map is in Architecture.

Documentation

Start here: Getting Started · FAQ · Chat Commands · Configuration

Using it well: Agents · Skills · Model Routing · Memory System · Project Planner · Ideation · GitHub Workflow · Delivery · UI Studio · UI Studio builder plan · CLI

Trust and safety: Security · Tool Execution

Under the hood: Architecture · Development · Chat reliability and capability broker plan · Local CI and safe runners · Roadmap · Contributing

Open source, and staying that way

AtlasMind is MIT licensed. There is no paid tier, no feature gate, and no plan to add one.

Contributions are welcome — see CONTRIBUTING.md. If AtlasMind saves you time, sponsorship helps keep it going.

MIT License — see LICENSE.