MAMahmoud Abujadallah
← Writing & Talks

Cursor Is Quietly Becoming an Agent Operating System

June 19, 2026 7 min read Originally on Medium ↗

If you’ve been using Cursor as “VS Code with a smarter autocomplete,” the last few weeks have been a signal that the product is heading somewhere very different. Across June 2026, Anysphere shipped a run of changelog updates — and then, at its first Compile conference, announced Origin, a GitHub competitor. Taken together, these reframe what Cursor actually is. The editor is no longer the center of gravity. The agent is.

I went through the recent changelog and the Origin announcement so you don’t have to. Here’s what changed, and why the pattern matters more than any single feature.

From editor to orchestration layer

The clearest theme is that work is moving off your machine. Cursor now lets you set up an entire development environment in the cloud in under ten minutes, watching the agent install dependencies in a shared terminal session as it goes. The setup gets captured as a reusable snapshot and can be committed to .cursor/environment.json, so the whole team inherits a fast cold-start instead of each person fighting their own "works on my machine" problem.

On top of that foundation sits the most interesting addition: cloud subagents. Type /in-cloud and Cursor spins up a subagent on its own VM and its own branch to handle the next task you submit. Your local workspace stays clean while long-running or parallel work — fixing CI, investigating a flaky issue, exploring an unfamiliar codebase — happens somewhere else entirely. There's even a /babysit command that hands a pull request to a cloud agent, which iterates remotely to get the PR ready to merge without tying up your session.

The handoff goes both directions. You can push long-running work to the cloud, run as many agents in parallel as you want, then pull a cloud agent back down to local when you want to test its changes yourself. That bidirectional movement is the part that feels genuinely new. Your “session” is no longer pinned to one computer; it’s a portable unit of work you can relocate based on what it needs.

Automation grows up

Cursor Automations — always-on agents that handle repetitive tasks — got a batch of upgrades that lower the barrier to setting them up. The headline is a /automate skill: describe in plain language what you want automated, and Cursor configures the triggers, instructions, and tools for you. No more assembling the pieces by hand.

The trigger surface widened too. There’s a new Slack emoji trigger, so reacting to a message with a designated emoji kicks off an automation right from your team’s chat. On the GitHub side, automations gained five new triggers covering issue comments, PR review comments, submitted reviews, resolved or unresolved review threads, and completed Actions workflow runs. Cursor seeded its marketplace with templates for triaging failed GitHub Actions and auto-fixing PR review comments to give people a starting point.

Maybe the most forward-looking piece: cloud agents launched by automations can now use a computer of their own to produce demos or artifacts of their work. The computer use tool is on by default — you just ask the agent to include a demo in your instructions. An automation that not only does the task but shows you the result is a meaningfully different thing than a script.

Bugbot gets faster, cheaper, and better at once

It’s rare to improve speed, cost, and quality in the same release, but that’s what happened with Bugbot, Cursor’s code review agent. Average review time dropped from around five minutes to roughly 90 seconds — over three times faster. It now finds about 10% more bugs per review (0.62 versus 0.56 on average) and costs around 22% less per run. The gains come from progress training Composer 2.5, the model now powering Bugbot.

Workflow-wise, you can run reviews before you push code. The /review command lets you pick which agents to run, with /review-bugbot and /review-security as direct shortcuts. Helpfully, /review syncs with Bugbot on GitHub and GitLab — if you review a diff locally and then open a PR with the same diff, Bugbot recognizes it, skips the redundant pass, and just leaves a note saying so. You can also configure it to review only what's new since the last pass, keeping feedback focused.

Design Mode learns to listen

For the front-end crowd, Design Mode in the Cursor browser picked up two nice ergonomic wins. You can now multi-select elements — click two or more together, and the agent sees the selected elements, their code, the surrounding layout, and the visual relationships between them. That makes requests like “make this one match the other” or “adjust this whole group” actually tractable.

The second addition is voice input. You can narrate UI changes through the Design Mode overlay, and the mic stays live while an agent is mid-run, so you can queue up the next change by voice without waiting for the current one to finish. It’s a small thing that nudges the interaction model toward something more conversational and less click-heavy.

The SDK quietly becomes production-grade

The update with the least flash and arguably the most long-term significance landed in the Cursor SDK, across both its TypeScript and Python flavors. A few standouts:

Custom tools. You can now hand the local agent your own functions via local.customTools instead of standing up a separate MCP server. The SDK exposes them through a built-in custom-user-tools MCP server, so your code runs through the same permission gate as any other tool, and every subagent can see them.

Auto-review for headless runs. Since there’s no human in the loop in an automated run, you can route tool calls through a classifier that decides what runs automatically and what gets held back. You steer it with plain-language rules in permissions.json — allow read-only inspections of build artifacts, say, while always pausing on destructive deletes.

Pluggable storage. Agent and run metadata no longer has to live in SQLite. There’s now a JSONL store you can diff and check into version control, and a public LocalAgentStore interface for backing state with anything from an in-memory store for CI to Postgres in production.

Nested subagents. Subagents can spawn their own subagents to any depth, each keeping its own prompt and model, with nothing to configure.

Round it out with reliability fixes — a requestId on every run for tying scripts back to backend logs, more reliable wait() behavior, cloud streaming over HTTP/1.1, lighter imports, and bundled ripgrep — and you have an SDK that's clearly being hardened for real production use rather than experimentation.

And then there’s Origin

The changelog tells one story; the Compile conference told a bigger one. In mid-June 2026, Cursor announced Origin — a git hosting and code collaboration platform built for AI agents, not just humans. Put plainly, it’s a full code storage and hosting platform aimed squarely at GitHub, designed from the ground up for a world where agents do most of the committing. A waitlist is open now, with a fall release window.

The premise is architectural. Git was designed for humans: open a branch, write code over a few hours, open a pull request, wait for review — a cadence measured in hours and days. Origin assumes the opposite load profile, where lots of agents are cloning, branching, committing, rebasing, reviewing, and fixing failures in parallel, in seconds. The demo numbers Cursor showed made the ambition concrete: throughput in the range of dozens of commits per second inside a single repo, plus hundreds of thousands of clones per hour, with an AI-powered engine for resolving merge conflicts automatically.

Origin didn’t appear out of nowhere. The team behind it came from Graphite, the code-review startup Cursor acquired, known for its “stacked pull request” workflow for managing dependent changes in parallel. That acquisition suddenly looks much more deliberate: Graphite supplies the review and collaboration layer, and Origin adds the hosting layer underneath it.

(A note for the skeptical: a few posts circulating alongside the announcement floated unverified or tongue-in-cheek claims — including a supposed SpaceX acquisition and a trillion-parameter model — so treat those with caution. The Origin announcement itself is well-corroborated; the surrounding noise is not.)

The bigger picture

Read the changelog as a list of features and it’s a solid month. Add Origin and read the whole thing as a strategy, and it’s something far more pointed. Cloud environments, portable agent sessions, computer-using automations, a production SDK, a review agent fast enough to run before every push, and now a Git forge built for agent-scale traffic all point in the same direction: Cursor wants to own the entire pipeline — write code in the editor, run agents in parallel, review with Graphite-style workflows, and host and merge on Origin.

The editor is becoming a control panel, and Origin is the infrastructure layer that ambition always implied. Whether that’s where you want your development workflow to live is a real question — but it’s no longer a hypothetical one. It’s shipping, one changelog entry at a time, with the foundation already laid for the rest.

References

Images courtesy of the official Cursor changelog. Article based on the Cursor changelog and Origin coverage from early to mid-June 2026.

Read & clap on Medium ↗ ← All writing & talks