Cursor Glass Is What Happens When an IDE Stops Pretending to Be About Files

Cursor has been a VS Code fork with good AI features for two years. That identity just changed. On March 19, 2026, the company shipped Glass, a new interface that puts agents at the center and pushes files to the edges. It landed alongside Composer 2, Cursor’s first proprietary coding model, trained entirely on code.

Glass is currently in early alpha. You can try it at cursor.com/glass, and users on Cursor 2.7.0+ may see it as the default. If you want the old layout back, run cursor --classic.

Open post on X

What Glass Looks Like

Open Cursor with Glass and the first thing you’ll notice is what’s missing: the file tree. Instead of the traditional VS Code layout where a left sidebar lists your project files and the center shows open editors, Glass gives you an agent sidebar on the left with a prompt-first home screen in the center.

The home screen has a single input field (“Plan, Build, @ for context”), a model selector (set to “Auto” by default), a microphone button for voice input, and two action buttons: “Plan new idea” and “Open editor.” Below the input, your sidebar lists active agents grouped by repository, each with a status indicator and a truncated description of what the agent is doing.

There’s also a Marketplace button at the top and a “New Agent” shortcut (Cmd+N). The overall feel is closer to a project management dashboard than a code editor. Files still exist, but they show up as inline “context pills” when an agent references them, not as the primary organizing principle.

You can toggle back to the classic editor mode at any time. Glass doesn’t replace the editor, it wraps around it.

Composer 2: Cursor’s Own Model

Glass shipped on the same day as Composer 2, and the two are designed to work together. Composer 2 is Cursor’s first model trained exclusively on code data, built in-house by Anysphere (Cursor’s parent company, valued at $10 billion as of the most recent funding round).

The Composer 2 blog post makes two main claims: the model matches frontier models on coding benchmarks at significantly lower cost, and it’s fast enough to power background agents without eating through your usage credits.

Pricing bears this out. Composer 2 runs at $0.50 per million input tokens and $2.50 per million output tokens at standard speed, or $1.50/$7.50 at the faster default tier. Compare that to Claude Opus at $5/$25 or GPT-5.3-Codex at similar rates. Cursor is betting that a smaller, code-specialized model can outperform generalist models on the tasks that actually happen inside an IDE.

The model is available inside all Cursor plans. Glass uses it by default when you select “Auto” in the model picker, though you can still choose from Claude, GPT, Gemini, Grok, or any other supported provider.

Multi-Agent Parallel Execution

The feature that makes Glass feel genuinely different from “Cursor with a new skin” is parallel agent execution. You can run up to eight agents simultaneously on the same codebase, each working on a separate task.

Cursor handles the file conflict problem through git worktrees or remote machines. Each agent gets its own isolated copy of the relevant files, so two agents editing the same file don’t collide. When an agent finishes, you review and merge its changes like you would a pull request.

This is where the Glass interface earns its design. The agent sidebar becomes a live dashboard: you can see which agents are running, what they’re working on, and how far along they are. Click into any agent to see its plan, code changes, and terminal output. The classic editor view doesn’t present this information as naturally because it wasn’t designed around multiple concurrent agents.

Planning Mode

Glass separates planning from execution more cleanly than previous Cursor versions. When you type a prompt and hit “Plan new idea” (or Shift+Tab), the agent enters Plan Mode: it researches your codebase, asks clarifying questions if needed, and produces a reviewable plan before writing any code.

You can create a plan with one model and build with another, which is useful for cost management. Use a cheaper model to explore and plan, then switch to a stronger model for the actual implementation. You can also run parallel agents on the same planning prompt, get multiple plan options, and pick the best one before any code gets written.

This might sound like a minor workflow change, but in practice it addresses one of the most common complaints about AI coding agents: they start writing code before they understand the problem. Planning mode forces a pause, and it’s enforced at the interface level, not just through prompt engineering.

Marketplace and Automations

Cursor launched its plugin marketplace in February 2026 with over 30 plugins from companies like Atlassian, Datadog, GitLab, Hugging Face, and PlanetScale. Plugins can bundle MCP servers, skills, subagents, hooks, and rules. Team admins can create private marketplaces for internal tooling.

Automations take agents a step further. You can set up always-on agents triggered by Slack messages, Linear tickets, GitHub events, PagerDuty alerts, webhooks, or schedules. These run in cloud sandboxes with persistent memory, so the agent learns from previous runs. TechCrunch covered the automation system earlier this month when it first rolled out.

Community Reaction: Split Down the Middle

Early responses to Glass are divided in a way that says something about where AI coding tools are headed.

One user on X described the experience as: “Now Cursor feels more like an Agent Orchestrator than an IDE. Managing agents in parallel is easier, the focus stays on the model chat, but the ability to check changes is still there.”

On the Cursor forum, the reaction is more mixed. The biggest complaint is documentation. There are no official docs, no screenshots, no walkthrough videos, and no changelog entry specifically for Glass. The “learn more” link on the Glass page goes to the Composer 2 blog post, which barely mentions Glass. Users had to discover the cursor --classic revert command through community discussion, not official docs.

Some users on Windows reported “Unrecognized deep link” errors when trying to activate Glass from the website. Others found themselves unable to revert after updating.

The more interesting pushback is philosophical. A forum thread titled “The Future of Cursor Is Becoming Claude Code” argues that Glass represents a pivot from human-AI collaborative editing toward fully autonomous agents, and that some developers don’t want that. The poster, who described themselves as a “hardcore Cursor supporter,” said they might switch to Claude Code if Cursor continues down this path.

That tension, between developers who want AI to amplify their editing and developers who want AI to do the editing for them, is exactly the fault line Glass sits on.

How Glass Fits the Competitive Landscape

The AI coding tool market has splintered into two camps. On one side: terminal agents like Claude Code, Codex, and Gemini CLI that work outside the editor entirely. On the other: IDE-integrated tools like Cursor, Windsurf, and GitHub Copilot that live inside the editing environment.

Glass is Cursor’s attempt to claim territory in both camps simultaneously. The agent orchestration view, parallel execution, and automation features compete directly with autonomous agents. The “Open editor” button and classic mode fallback keep the IDE users around.

Whether that bet pays off depends on whether developers actually want their agent orchestrator and their code editor in the same window. The community reaction suggests the answer is “some do, some don’t,” and Cursor knows this. That’s why Glass is a toggle, not a mandate.

Pricing

Glass doesn’t cost extra. It’s part of your existing Cursor subscription:

Plan	Price	What You Get
Hobby	Free	Limited agent requests and completions
Pro	$20/mo	Extended limits, all models, cloud agents
Pro+	$60/mo	3x usage credits
Ultra	$200/mo	20x usage credits, priority feature access
Teams	$40/user/mo	SSO, analytics, admin controls
Enterprise	Custom	Pooled usage, SCIM, audit logs

Composer 2 runs at a fraction of the cost of third-party models, so using it as your default in Glass keeps your usage credits lasting longer than they would with Claude or GPT.

Try It

Glass is in early alpha, which means bugs, missing features, and interface changes are expected. If you’re on Cursor 2.7.0+, visit cursor.com/glass to activate it. If you don’t like it, cursor --classic brings back the layout you know.

The alpha label means Cursor is collecting feedback before committing to this as the default experience. If you have opinions about what an agent-first IDE should look like, now is when those opinions actually matter.

Sources: