Cursor Just Became an Always-On Agent Platform

Cursor shipped two updates in two days this week. Together they push it well past "AI code completion tool" into something closer to an always-on engineering agent platform.

TL;DR: Cursor Automations lets you build agents that run on schedules or trigger from Slack, GitHub, Linear, and PagerDuty. Cursor is also now available inside JetBrains IDEs (IntelliJ, PyCharm, WebStorm) via the Agent Client Protocol. Both are available now.

Cursor Automations: Agents That Run Without You

Released March 5th. This is the bigger of the two updates.

Automations let you define agents that run automatically based on triggers. You write the instructions once, configure which MCPs and model to use, and the agent handles the rest on its own cloud sandbox.

Supported triggers out of the box:

• Schedules (cron-style)
• Slack messages
• GitHub PRs opened or updated
• Linear issues created
• PagerDuty incidents
• Custom webhooks

Each automated agent runs in an isolated VM, has access to your configured MCPs, and also has a memory tool so it can learn from previous runs and improve over time. It verifies its own output before finishing.

Cursor uses Automations internally in production. A few examples they shared:

Security review: Triggers on every push to main. Audits the diff for vulnerabilities, skips issues already discussed in the PR, posts high-risk findings to Slack. They say it has caught multiple real vulnerabilities.

Agentic codeowners: Runs on every PR. Classifies risk based on blast radius, complexity, and infra impact. Low-risk PRs get auto-approved. Higher-risk ones get reviewers assigned based on contribution history. Decisions are logged to Notion via MCP for audit.

Incident response: Triggered by PagerDuty. Uses Datadog MCP to investigate logs, checks recent code changes, sends a Slack message to on-call engineers with a proposed fix PR attached. Significantly reduced their incident response time.

Bug report triage: When a bug lands in Slack, the agent checks for duplicates, creates a Linear issue, investigates root cause in the codebase, attempts a fix, and replies in the original thread.

This is the kind of automation that used to require dedicated tooling (custom bots, n8n pipelines, on-call scripts). Cursor is packaging it as a first-class feature inside the IDE.

Create automations at cursor.com/automations or start from a template in their marketplace.

Cursor in JetBrains: Finally

Released March 4th. Cursor is now available as a plugin inside IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs via the Agent Client Protocol (ACP).

This matters for backend teams. A lot of Java, Kotlin, and Python developers are on JetBrains and have not had a reason to switch to VS Code-based editors. Now they do not have to.

Install the Cursor ACP plugin directly from the JetBrains marketplace, authenticate with your existing Cursor account, and you get access to the same frontier models (OpenAI, Anthropic, Google, Cursor) with agent-driven development inside the editor you already use.

What This Means for Backend Teams

The combination of Automations and JetBrains support is notable. Automations means your codebase can have agents watching it 24/7 for security issues, test coverage gaps, and incident signals. JetBrains support means your whole team can adopt this regardless of editor preference.

The part worth paying attention to: agents that have memory and improve with repetition. That is a different category from one-shot code generation. If an automation runs 200 times over two months and learns from each run, the output quality in month two is not the same as month one.

Whether that actually works well in practice is still TBD. But the architecture is there.

Sources: Cursor Changelog (cursor.com/changelog), Cursor Blog (cursor.com/blog/automations)