Singularity vs VS Code: agent-ready editor or agent board?

Visual Studio Code is the editor many developers open every morning, with their extensions and habits. With GitHub Copilot agents, it now does much more than complete code: it hands tasks to local agents, tracks several sessions in a dedicated window, delegates to a cloud agent that opens a pull request, and hosts Claude or Codex.

So the real question is not “does VS Code have agents?” but “where should delegated work live?” In VS Code, it lives in sessions attached to the editor. In Singularity, it lives in Kanban tickets, each executed in its own Git worktree, then reviewed and integrated.

Comparison checked on October 10, 2026 against the official VS Code and GitHub Copilot documentation and Singularity’s documentation. It compares workflows, with no speed or generated-code quality benchmark. Public prices in USD/EUR as displayed, excluding taxes and usage; they may change.

In short

• VS Code remains an editor to which Copilot adds agents: the Chat view, the Agents window, a CLI, a cloud agent and third-party harnesses. Its extension ecosystem has no equivalent in Singularity.
• Singularity starts from the ticket: every request becomes a card executed in an isolated worktree, with status, dependencies, a report and file-by-file review.
• Both isolate and parallelise with worktrees; the difference is coordination (sessions or linked tickets) and integration (pull request or ordered local rebase).
• Costs do not compare line by line: Copilot bills by plan and AI credits; Singularity is free, but you pay your AI providers.
• They combine: Singularity drives the Copilot CLI, and VS Code opens any Singularity worktree.

VS Code and its agents

VS Code is free for private and commercial use and runs on macOS, Linux and Windows; its source code is MIT-licensed, while Microsoft’s distribution uses a product licence (VS Code FAQ). The Extension Marketplace adds languages, debuggers and tools.

The documentation describes several agent harnesses. Copilot, recommended for daily work, runs in an Agent Host on your machine, a connected host or a Dev Container; the Copilot CLI works in the terminal. Claude uses the Claude Agent SDK and requires a Copilot subscription or a Claude API key; Codex runs through the OpenAI extension, with Copilot Pro+ or a ChatGPT account. The Cloud harness runs on provider infrastructure and returns a pull request; third-party cloud agents are in preview.

The Agents window is where you delegate and track sessions across projects, optionally in a grid. A session can be isolated in a worktree, start from a pull request, target a host over SSH or a tunnel (remote sessions) or run in a Dev Container (experimental). Subagents handle focused tasks in their own context. The docs point out that a worktree isolates changes but is not a security boundary (overview).

Models come from your Copilot plan, your own key (BYOK) or a local model, subject to organisation policies. The Copilot cloud agent works in an ephemeral environment on a single GitHub-hosted repository, with one branch and one pull request per task and a 59-minute maximum per session.

Copilot plans: Free, Pro (USD 10/month), Pro+ (USD 39), Max (USD 100), Business (USD 19 per seat) and Enterprise (USD 39 per seat), each with AI credits. According to the plans page, one credit is worth USD 0.01, completions remain unlimited on paid plans, and delegating to Claude and Codex (preview) is limited to Pro+ and Max.

Singularity at a glance

Singularity is a desktop ADE (Agentic Development Environment) by Meteor Factory. It combines an editor with language servers, terminals, a Git client (graph, diffs, stash, worktrees), multi-project workspaces and a Kanban board that runs agents.

A ticket holds a description, priority, attachments, dependencies and agent configuration. Once started, it becomes an observable mission in a dedicated Git worktree, ending with a report and a short resolution. Commits are rebased onto the base branch, after review when auto-merge is off.

Singularity drives the CLIs of seven providers: Claude Code, Codex, Copilot, Cursor, Gemini, Mistral and Ollama, with no model subscription included. The app is free (unlimited agents, projects and worktrees); the Singularity Licence, €24/month per workstation after a 14-day trial, only unlocks paid Marketplace plugins such as Pipelines (pricing). It runs on macOS, Windows and Linux (installation).

Comparison table

The same feature in both tools

Example: add a CSV export for invoices, with an API endpoint filtered by date range, a UI button and tests.

In VS Code, you open a Copilot session in the Agents window, isolated in a worktree, and describe the feature, possibly in plan mode. The agent edits the API and UI, runs the tests, and you review the diff before committing or opening a pull request. To parallelise, you open a second session or hand part of the work to the cloud agent, which comes back with a pull request. The link between those sessions lives in your head or your issue tracker.

In Singularity, you create a ticket with acceptance criteria and an attached mock-up, then split it into two children: API, then a UI ticket “blocked by” the API. The scheduler starts the API in its worktree; the UI waits until the API is done and integrated. Each card shows its phase (reading, writing, testing, committing). The Review tab then shows each diff: approve file by file, annotate a line or rerun the agent with feedback.

Either way, tests and review remain essential: a worktree stops two agents from editing the same files, not from producing incompatible changes.

Parallel sessions or coordinated tickets

VS Code’s Agents window is built to follow many sessions: grouping by workspace, a grid, remote sessions, subagents. It works well for a developer who steers each agent personally.

Singularity adds a coordination layer. Dependencies decide launch order; a concurrent-agent limit protects the machine; a parent ticket waits for its children and synthesises their results; an agent question parks the ticket until you answer, and the reply goes back to the same session. Recurring runs can be scheduled daily or weekly, and the ticket keeps the history for the team. A few hand-steered sessions: VS Code is plenty. A steady stream of related tasks across repositories: a board that executes becomes useful.

Git, review and integration

In VS Code, the Local harness keeps edits pending so you can keep or undo each one; Agent Host sessions write directly to the folder or worktree, and you review the diff before committing (reviewing edits). Checkpoints help you roll back without replacing Git, and the cloud agent follows the standard GitHub flow.

Singularity integrates locally: each worktree’s commits are replayed onto the base branch by rebase, with no merge commit, in the order of a per-project integration queue. Review lets you approve all or some files, edit a file, reject, or rerun the agent. If your team requires pull requests, your forge stays downstream.

Models, accounts and cost structure

With VS Code, model access goes mainly through Copilot: a plan with a credit allowance, optional extra credits and organisation policies. The Claude and Codex harnesses also accept a Claude key or a ChatGPT account.

Singularity resells no models: each provider is billed through your own subscription or usage (Anthropic, OpenAI, GitHub…). Prompts pass through the chosen provider; only local Ollama inference stays on the machine. Your real cost is the sum of provider subscriptions plus, if needed, the licence.

Where VS Code is stronger

• Ecosystem: extensions for languages, debuggers, frameworks and team tools, which Singularity does not run.
• Continuity: no migration; agents arrive in the tool you already use.
• GitHub integration: a cloud agent started from an issue, pull request sessions, one plan covering completions, chat and agents.
• Execution environments: SSH or tunnel hosts, Dev Containers, cloud; Singularity runs agents on the machine where it is installed.
• Entry price: VS Code and Copilot Free cost nothing.

Where Singularity stands out

• The ticket as the unit of work: dependencies, priority, children, status, report and resolution in one card.
• A scheduler that starts the next ready ticket based on dependencies, priority and the agent limit.
• Review designed for agents: per-file approval, partial merge, notes on a selection, rerun with feedback.
• Linear integration by ordered rebase, with explicit recovery after a crash.
• Per-ticket provider choice among seven CLIs, and an MCP gateway scoped to each session.

Can you use both?

Yes, and it is often the most sensible setup. A Singularity worktree is an ordinary Git folder under .singularity-worktrees/: open it in VS Code to debug, use an extension or finish a change by hand.

Singularity can also drive the GitHub Copilot CLI as a provider: if your organisation already pays for Copilot, you reuse that account from the board, or switch a ticket to Claude Code or Codex. If you are also weighing a VS Code-based editor, read Singularity vs Cursor.

Which tool should you choose?

• You mostly code yourself and delegate occasionally: VS Code with Copilot.
• Your team lives in GitHub (issues, PRs, Actions): the Copilot cloud agent fits right in.
• You delegate many related tasks across repositories: Singularity brings the board, dependencies and per-ticket review.
• You want to pick the provider task by task with your accounts: Singularity orchestrates seven CLIs.
• You depend on specific extensions: keep VS Code as your editor and add Singularity for orchestration.

Trial protocol

1. Pick a real feature touching an API and a UI, with acceptance criteria and existing tests.
2. In VS Code, build it with Copilot in the Agents window, in a worktree session; record preparation, review and integration time.
3. In Singularity, create the same ticket, run it with the same provider (Copilot) and turn auto-merge off.
4. Compare tracking clarity, review quality, the number of corrections and the final Git history.
5. Record the costs actually billed rather than an estimate.

Frequently asked questions

Is Singularity a VS Code fork?

No. It is a standalone Electron application with a CodeMirror 6 editor and its own Marketplace. It does not run VS Code extensions.

Can I use my GitHub Copilot subscription in Singularity?

Yes: install the GitHub Copilot CLI, authenticate with copilot, then select Copilot as a ticket’s provider. Your organisation must allow Copilot.

Doesn’t the VS Code Agents window already do the same thing?

It manages parallel sessions with worktrees and subagents. Singularity differs through tickets: dependencies, scheduling, a board, per-file review and ordered integration.

Does my code stay on my machine?

With Singularity, agents work locally, but prompts and excerpts go to the chosen provider, except with local Ollama. With VS Code, it depends on the harness: local, remote host or cloud.

To go further: all Singularity comparisons, the getting started guide, or download Singularity to try it on your repository.