AtlasMind

_{· Current source version: 0.270.3 ·}

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.

Deliver a client website. Website Studio carries a site from the client brief through a sitemap that draws its own hierarchy, a wireframe canvas you actually draw on, a shared design system, and a protected path to production. Select any block and say what you want in plain English; press Generate at any stage and watch it render in a preview beside you.

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

Since the last Marketplace publication, v0.266.3, source builds have added the following. The full history is in CHANGELOG.md.

• 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, Website 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, so your own keystroke stays the last gate on a single command; 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 the result renders in a preview window beside the Studio. 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 when you close the window.

• Every panel now looks like the Project Dashboard. Settings, MCP, Model Providers, Agent Manager, Mission Control, Run Center, Cost Dashboard, Model Comparison, Website 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 116 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 · Website Studio · CLI

Trust and safety: Security · Tool Execution

Under the hood: Architecture · Development · 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.