VS Code extension

Your projects, tasks and coding agent inside VS Code

The Autoplans VS Code extension puts your projects and tasks in the sidebar, draws the task map in an editor tab, and hands GitHub Copilot's agent mode nineteen tools that read and update the same backlog.

It is a VS Code task management extension backed by an account rather than a file on one machine. The same projects appear in the desktop app, the CLI, the Obsidian plugin and any other MCP client you connect, so the plan does not fork once per tool.

Install and connect

  1. 1

    Install the extension

    Search the Extensions view for AutoPlansDev.autoplans-vscode — the publisher has more than one extension listed — or install it by identifier from a terminal. The extension declares VS Code 1.80 or newer.

    code --install-extension AutoPlansDev.autoplans-vscode
  2. 2

    Sign in from the editor

    Run Autoplans: Sign in with Browser from the command palette. The editor opens autoplans.dev, you approve while already signed in there, and the key comes back over the editor's own URI handler — checked against a random state value — and goes straight into SecretStorage. Autoplans: Set API Key is still there if you would rather paste a key from Settings → API keys.

    Ctrl+Shift+P → Autoplans: Sign in with Browser
  3. 3

    Link the folder to a project

    A folder belongs to a project when it carries .autoplans/project.json. Commit that file and everyone who clones the repository, plus every Autoplans app, resolves the same backlog without configuring anything.

    // .autoplans/project.json
    {
      "projectId": "1fb3fe7d-e3f9-4992-ae18-29b2bade4bd4",
      "name": "My project",
      "url": "https://autoplans.dev/dashboard/projects/1fb3fe7d-...",
      "linkedAt": "2026-08-26T10:00:00.000Z"
    }
  4. 4

    Open the map

    Autoplans: Show Task Map draws the linked project; a Task Map button sits in the status bar for the same thing. Autoplans: Show Task Map (Choose Project) always asks which project to draw, even in a linked folder.

  5. 5

    Write the Copilot instructions file

    Autoplans: Generate Copilot Configuration writes .github/copilot-instructions.md and a chat mode under .github/chatmodes/. VS Code applies an instructions file at that path to every chat request in the workspace, so Copilot picks up the project conventions and the Autoplans tools without being reminded each session.

  6. 6

    Install the agent runtime, if you want agent sessions

    Sidebar, map, chat participant and Copilot tools need nothing else. Agent sessions need the runtime, which is a separate npm package because the binary is far too large to ship inside an extension. Node 20 or newer; Autoplans: Install the Coding Agent opens a terminal and runs this for you.

    npm install -g autoplans-agent

What the extension does

Projects and tasks in the sidebar

The Autoplans.dev container in the activity bar holds a Projects & Tasks tree: Projects, Tasks, Sync & Generate, AI Assistant and Settings. Projects expand to a completed/total count each, then to their tasks with status and priority. Right-clicking a project offers the map, the dashboard, the AI chat, a new task, and the three file-writing commands.

The task map as an editor panel

One node per task, dependency arrows running left to right, and a drawer with subtasks, relations, linked commits and comments, plus Start, Mark done and Reopen. It is the same map implementation the dashboard, the desktop app and the Obsidian plugin draw, so the picture does not change when you move between them.

An AI coding agent in VS Code

Autoplans: New Agent Session — the sparkle in the editor title bar — opens a session that runs on your machine. autoplans.agentOpenIn decides whether it floats into its own window or stays as a tab. The extension host holds the runtime credentials on loopback; the webview only draws.

Nineteen tools Copilot agent mode can call

autoplans_list_projects, autoplans_create_task, autoplans_update_task, autoplans_bulk_create_tasks and fifteen more, including the business-plan and branding ones. Agents in VS Code invoke language-model tools on their own, and every one of these can also be aimed at a single prompt by name — #createTask, #listTasks.

An @autoplans chat participant

Address the participant directly in the Chat view to ask about projects and tasks. It carries slash commands: /projects, /tasks, /create, /sync, /plan, /brand, /status and /help. It confirms which project it is about to use rather than picking one for you.

Intelligent workspace detection

The extension reads .autoplans/project.json first and uses its projectId. Without that marker, the sync commands work out a name from package.json's name and description, then the root README's first heading and first paragraph, then .autoplans/README.md, falling back to the folder name — and match it against your projects case-insensitively, accepting an exact match or either name containing the other.

Files it writes for the rest of your toolchain

Autoplans: Generate Copilot Configuration writes .github/copilot-instructions.md and .github/chatmodes/. Autoplans: Initialize .autoplans Folder writes .autoplans/README.md, tasks.md, architecture.md and an empty tasks/. Both overwrite on each run, so keep hand-written notes somewhere else.

Four settings and no key in any of them

The API key lives in the editor SecretStorage, deliberately not in settings, so it is neither synced nor written to disk in plain text. The settings are autoplans.mcpEndpoint, autoplans.agentRuntimePath, autoplans.agentOpenIn and autoplans.telemetry.enabled, which turns off the error reports the extension sends about itself.

Manage a backlog without leaving VS Code

The usual arrangement puts the task manager in a browser tab and leaves the editor knowing nothing about it. Status then depends on somebody remembering to switch tabs and transcribe what they did, which is why most backlogs describe the repository as it was a fortnight ago.

Putting the backlog in the editor only helps if the thing doing the work can write to it. That is what the language-model tools are for: a session that finishes a task marks it completed and leaves a comment saying what it verified, and the node recolours in the map without anyone opening a tracker.

This holds without Autoplans in the picture. Any arrangement where the tool writing the code can also record what it finished will keep a truer backlog than one that asks a person to copy progress across.

GitHub Copilot project management from one backlog

Copilot's agent mode can call the language-model tools any installed extension contributes. Autoplans contributes nineteen, so a Copilot session can list your projects, read a task with its subtasks, create the follow-up work it discovers, and set statuses as it goes — against the same account the dashboard shows.

The instructions file matters as much as the tools. Autoplans: Generate Copilot Configuration asks the editor for a model, reads what the repository already documents — .github/copilot-instructions.md, AGENT.md, AGENTS.md, CLAUDE.md, .cursorrules, .windsurfrules, .clinerules, README.md — and writes an instructions file that keeps those conventions and names the task tools. Without a model available it falls back to a template. There is more on writing that file by hand in the guide to Copilot instructions at /guides/copilot-instructions.

The task map in VS Code

A node is a task. Border colour is status: emerald for completed, cyan for in progress or waiting for review, amber for blocked or failed, grey for pending. An amber dot marks high and critical priority, and a line of counts under the title gives the priority, the subtasks and the comments.

Arrows are dependencies and run left to right, so a task sits to the right of everything it depends on. The hub on the left is the project; tasks with no dependencies connect to it, which makes the leftmost column the work that can start now.

Clicking a node opens the drawer: description, status, priority and type, subtasks, relations you can click to jump to, linked commits with their branch and line counts, and comments with agent comments labelled. Start, Mark done and Reopen act on the task without leaving the panel.

A VS Code extension with an MCP server behind it

Everything the extension shows comes from the Autoplans MCP server at https://autoplans.dev/api/v1/mcp, over Streamable HTTP with your API key as a bearer token. The extension is one client of that endpoint; Claude Code, Cursor, Windsurf and Claude Desktop are others, and they all see the same projects.

What the extension adds on top is what a bare MCP connection cannot give you: the sidebar, the map as a panel, agent sessions, and the chat participant. Per-client configuration blocks are at /mcp-server, and the VS Code and Copilot one at /mcp-server/vscode-copilot.

You do not need the extension to give Copilot the backlog, though. VS Code reads MCP servers from .vscode/mcp.json in the workspace, and an input variable keeps the key out of the file you commit:

{
  "servers": {
    "autoplans": {
      "type": "http",
      "url": "https://autoplans.dev/api/v1/mcp",
      "headers": { "Authorization": "Bearer ${input:autoplansKey}" }
    }
  },
  "inputs": [
    { "id": "autoplansKey", "type": "promptString", "description": "Autoplans API key", "password": true }
  ]
}

A VS Code extension for AI sprint planning

Describe the project once — in the dashboard, to the chat participant, or in an agent session — and the planning agent returns tasks and subtasks with dependencies between them. The result is a draft to edit, not a plan to accept; renaming, deleting and reordering is expected.

There is no sprint object in Autoplans: no iteration, no burndown, no velocity chart. What planning produces is a dependency-ordered backlog, and the leftmost column of the map is what is unblocked today. If your team runs sprints, that column is what you pull from.

Questions

How to manage tasks inside VS Code?

Install the extension, sign in, and open the Autoplans.dev container in the activity bar. Projects lists every project with its completed/total count; expanding one shows its tasks with status and priority. Autoplans: Create Task adds one, Ctrl+Alt+P opens the full projects panel, Ctrl+Alt+A opens the AI chat for a project, and the status bar button opens the map.

Is this a VS Code kanban extension?

No. There is no board and nothing to drag: as a VS Code project management extension it gives you a tree in the sidebar and a dependency graph in an editor tab. Tasks carry a status — pending, in progress, blocked, completed, failed, waiting for review — which you change from the tree, from the map drawer, or through a tool call.

Is Autoplans a Copilot extension?

It extends Copilot Chat in the two ways VS Code supports: an @autoplans chat participant you address by name, and language-model tools that agent mode calls on its own. It is not a GitHub App, and it does not replace Copilot. Copilot writes the code; Autoplans holds the record of what the work was and what is left.

Do I need the coding agent to use the extension?

No. The sidebar, the task map, the chat participant, the Copilot tools and the file-writing commands work with the extension alone. Agent sessions are the one feature that needs npm install -g autoplans-agent on Node 20 or newer, because the runtime binary is around 180 MB and cannot be shipped inside an extension.

Where is my API key stored?

In the editor's SecretStorage, never in a settings file. Browser sign-in generates a random state value per attempt and ignores any callback it did not start, so a live key never travels through a clipboard. The agent runtime's loopback credentials stay in the extension host and are not handed to the webview.

Can I point the extension at a self-hosted deployment?

Yes. autoplans.mcpEndpoint defaults to https://autoplans.dev/api/v1/mcp; set it to your own /api/v1/mcp and reload the window. Browser sign-in derives its origin from that setting, so it follows the endpoint rather than going back to autoplans.dev.

Does it work in Cursor or another VS Code fork?

It is published to the Visual Studio Marketplace and to Open VSX, which is the registry Cursor installs third-party extensions from, so it can be installed there too; the Open VSX copy is published separately and can sit a version behind the Marketplace one. The sidebar, the map and the commands are ordinary extension APIs. The chat participant and the language-model tools are VS Code chat APIs, and a fork only has them if it ships that chat, so for the agent side connect the editor over MCP instead — the Cursor block is at /mcp-server/cursor — and you get the same projects and tasks.

What does it cost?

The extension is free to install and an account is free to create. Everything it reads and writes goes through the hosted MCP server, and that endpoint is a paid capability: a Free account calling it is refused with an upgrade message. The plans are at /pricing.

Start with one project idea.

Describe it, get a backlog, and point your agent at it. Free, no card.

Start free