Cursor Is No Longer Just an IDE
Automations, self-hosted cloud agents, JetBrains ACP support, and 30+ new plugins — Cursor has quietly shifted from AI-assisted coding tool to agent runtime. Here's what that transition actually means for how you build.
Cursor shipped four significant things in the last month. Taken individually, each looks like a product feature. Taken together, they describe a different kind of software entirely.
The IDE framing is starting to feel like the wrong lens.
What Shipped
Let’s be precise before getting into implications.
Automations (March 5) — agents that run automatically, triggered by schedules or by events from Slack, Linear, GitHub, PagerDuty, or custom webhooks. Cursor’s own framing: “a cron job that runs an AI coding agent instead of a shell script.” When triggered, an agent spins up an isolated cloud sandbox VM, clones the repo, executes against configured tools and MCPs, verifies its own output, and can open PRs or post back to the triggering system. Agents have access to a memory tool, so they learn from prior runs and improve iteratively without manual intervention.
30+ new plugins (March 11) — a marketplace expansion bringing in Atlassian, Datadog, GitLab, Glean, Hugging Face, monday.com, PlanetScale, and more. Most plugins bundle MCP servers, meaning they’re not just available for manual agent sessions — they wire directly into cloud agents running inside Automations. Trigger an automation from a PagerDuty alert and the agent can query Datadog, pull recent commits, and file a Linear issue without you touching anything.
JetBrains support (March 4) — Cursor is now available inside IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs via the Agent Client Protocol (ACP) — a standard built by JetBrains and Zed Industries that does for AI agents what LSP did for language servers. The ACP Agent Registry went live in January, replacing manual JSON config with one-click installation from inside the IDE. This decouples Cursor’s agent layer from its own editor and makes it a capability you plug into whichever IDE your workflow already uses.
Self-hosted cloud agents (March 25) — Cursor-hosted agents running inside your own infrastructure. An outbound-only HTTPS connection to Cursor’s inference engine; tool calls and code execution happen locally. Kubernetes deployment via Helm charts. No inbound ports, no VPN tunnels, no firewall changes. Your codebase, build artifacts, and secrets never leave your network.
The Actual Shift
The category being created here isn’t “AI IDE”. It’s closer to an agent runtime with an IDE attached.
The distinction matters. An AI IDE helps individual developers write code faster. An agent runtime executes development workflows autonomously — on schedules, on events, at team scale — and hooks into the systems your engineering organisation already uses. The human isn’t necessarily in the loop for each execution. They define the instructions, configure the triggers, and review outputs.
This is not autocomplete. It’s closer to how you’d think about a CI/CD pipeline, except the worker is an LLM with tool access instead of a bash script.
The Automations feature makes this explicit. The listed use cases in Cursor’s own documentation read like a DevOps backlog:
- Security audit on every push — without blocking PRs
- Risk classification assigning reviewers based on blast radius and complexity
- Incident response using Datadog logs and recent code changes
- Weekly repository change summaries posted to Slack
- Test coverage identification with automatic PR generation
- Bug report deduplication and root cause investigation
None of these are IDE features. They’re scheduled workers. The only thing that’s changed is what’s doing the work.
Why the Plugin Expansion Matters
The jump to 30+ plugins isn’t a catalogue update. It’s the infrastructure layer for the Automations use cases above.
MCP — the Model Context Protocol originally developed by Anthropic — is doing a lot of work here. When a plugin bundles an MCP server, it’s not just adding a UI widget to the editor. It’s exposing a structured, composable interface that any agent in the system can call. Worth noting: Cursor plugins go beyond raw MCP servers — they bundle usage instructions (skills) that tell agents how to use the tools effectively, which Cursor reports makes them significantly more effective than pointing a bare MCP config at the same endpoint. Teams and Enterprise accounts can also publish private internal plugins, distributing proprietary tooling across the organisation. An automation triggered by a Slack message can invoke the Datadog MCP, query the Notion MCP, update Linear — all inside a single execution without any custom integration code.
This is the same pattern Shopify is pursuing with their first-party MCP server: treat external tools as agent-callable APIs, not just human-operated UIs. Cursor is building the marketplace for that model inside the development workflow specifically.
The more plugins that land in the Cursor marketplace, the more powerful Automations become without additional engineering work. That compounding matters.
Self-Hosted Agents and the Enterprise Play
The self-hosted cloud agents announcement is the clearest signal of where Cursor is pointing commercially.
The architecture is smart: Cursor’s inference engine stays in the cloud handling model calls, while a worker process runs inside your network and executes tool calls locally. Your code never leaves. Agents get access to internal caches, dependencies, and network endpoints — functioning like a service account with existing security clearance rather than an external system trying to reach in.
Each agent session gets an isolated VM with terminal, browser, and desktop access. Kubernetes deployment via Helm for teams running at scale. Ephemeral or long-lived workers depending on your requirements.
This design directly addresses the reason enterprises hesitate to adopt cloud AI tooling: data residency, compliance, secrets management. The pitch is identical capabilities to hosted agents — isolated environments, multi-model support, full plugin access, team permissions — without code leaving your perimeter.
Early adopters make the compliance case directly. Brex: “Now with self-hosted cloud agents, we can give them access to the infrastructure needed to run our test suites and validate changes with our internal tools.” Money Forward, a Japanese financial services provider: “Given our strict security requirements as a financial services provider, self-hosted support is something we’ve been eagerly awaiting.” Notion: “In large codebases like Notion’s, running agent workloads in our own cloud environment allows agents to access more tools more securely.”
If you’re in a regulated space (financial services, healthcare, defence-adjacent), this is the unlock. The feature set that’s been available to teams without those constraints is now available with them.
ACP and the IDE Decoupling
JetBrains support via ACP is interesting less for the JetBrains use case specifically and more for what it signals.
The Agent Client Protocol is a layer that separates Cursor’s agent capabilities from Cursor’s editor. When that separation exists, Cursor stops being “one editor with AI built in” and becomes “an agent system that integrates with editors.” That’s a fundamentally different product surface area.
The practical near-term implications: teams running JetBrains IDEs for Java, Kotlin, or other JVM-stack work can now access the same frontier models and agent-driven development that Cursor users have had. But the longer-term implication is that ACP creates an integration point for any development environment, not just JetBrains. The editor becomes an interface to the agent runtime rather than the system itself.
For Kotlin Multiplatform workflows specifically, this lands well. Android Studio and IntelliJ are the natural home for KMP development; having Cursor’s agent layer available there rather than requiring a context switch to a different editor is a meaningful quality-of-life improvement.
What This Means If You’re Building Workflows
The practical application here isn’t theoretical.
Automations wired to GitHub events and Linear can replace a significant slice of the low-value cognitive load that accumulates in every engineering workflow: triage, risk classification, test gap identification, incident investigation bootstrapping. These are tasks where the output needs to be good enough to act on, not perfect — exactly where current LLMs perform well.
The memory tool is the part I’d watch most carefully. An automation that can learn from its own past runs and adjust its behaviour without manual re-prompting is qualitatively different from a one-shot agent. It starts to look like a system that improves with use, not just one that executes instructions. Early evidence bears this out: 35% of Bugbot Autofix suggestions — where an agent proposes fixes on pull requests autonomously — are being merged directly into base branches. That’s a meaningful signal that agent output is landing at a quality that developers trust enough to ship.
Self-hosted agents mean this model is available for codebases that can’t leave the building. If you’ve been waiting for the compliance answer before adopting cloud agent tooling, this is it.
The plugin marketplace means the integration surface is expanding faster than any single team could build custom tooling for. Datadog, GitLab, Hugging Face, monday.com — the connective tissue between agent execution and the tools your workflow already depends on is being built out systematically.
The Bigger Picture
What Cursor is building is an answer to a question the industry has been circling around: where does the agent runtime live in a development workflow?
The IDE is an intuitive answer because that’s where developer attention is. But Cursor’s recent releases suggest the more useful frame is the opposite: the agent runtime is where development work happens, and the IDE is one of several interfaces into it. Automations run without a human present. Self-hosted agents operate inside your infrastructure like a service. ACP makes the agent layer portable across editors.
This isn’t autocomplete at scale. It’s a different category of tooling, and the pace of shipping over the last month suggests Cursor knows exactly what they’re building.
Further reading: Cursor Automations · Self-Hosted Cloud Agents · JetBrains Integration · Plugin Marketplace · Model Context Protocol