The Always-On Agent Convergence: Three Tools, One Week, One Paradigm Shift

In the span of 72 hours — March 4 to 7, 2026 — Cursor, OpenAI, and Anthropic each shipped features that share an unmistakable thesis: AI coding agents should run without you watching.

This wasn't coordinated. But it wasn't coincidence either. The prompt-and-monitor era of AI coding is ending. What's replacing it is a world where agents trigger on events, run on schedules, fan out across tasks, and loop you in only when they need a decision.

Here's what shipped, what it means, and why this week matters more than any single model release.

What Shipped

Three different approaches to the same insight: developers shouldn't have to be the ones pressing Enter.

Cursor Automations: The Event-Driven Agent

Cursor Automations is the most ambitious of the three. It turns Cursor into an event-driven platform where agents spin up automatically in isolated cloud sandboxes, triggered by real-world development events.

The trigger sources tell the story:

• GitHub: PR merged, issue opened, push to branch
• Slack: Message in a channel
• Linear: New issue created
• PagerDuty: Incident fired
• Webhooks: Anything else

Each automation runs in its own sandbox with memory from prior runs. Cursor says they're running hundreds of automations per hour internally. Their own engineering team uses them for security audits on every push, PR risk assessment with auto-approve for low-risk changes, and weekly repo digests posted to Slack.

The most telling detail: 30%+ of Cursor's own PRs are now created by autonomous agents. BugBot — their code review agent — graduated from standalone tool to just another Automation.

Jonas Nelle, Cursor's async agents lead, put it plainly: "Humans aren't always initiating. They're called in at the right points in this conveyor belt."

Rippling, an early adopter, deployed automations that convert meeting notes into action items and PRs on a two-hour cadence, auto-create Jira tickets, triage incidents, and generate weekly status reports. This isn't a coding tool anymore. It's workflow infrastructure.

Claude Code /loop: The Cron-Native Agent

Claude Code v2.1.71 took a different path. Instead of event triggers, Anthropic shipped /loop — a command that runs any prompt on a recurring interval using standard cron expressions.

# Poll a deployment every 5 minutes
/loop 5m check if staging is healthy and alert me if not

# Run tests every hour
/loop 1h run the test suite and summarize failures

# Full cron expression: every weekday at 9am
CronCreate 0 9 * * 1-5 "review open PRs and summarize"

The details are pragmatic. Tasks fire between your turns, not mid-response. Times use your local timezone. Sessions hold up to 50 scheduled tasks with a 3-day auto-expiry. If Claude is busy when a task comes due, it queues until idle.

This is the Unix philosophy applied to AI agents: small, composable, transparent. You can see what's scheduled, cancel anything by ID, and the whole system dies when you close the terminal. No cloud sandbox, no event bus — just cron.

It's less flashy than Cursor's approach, but it maps perfectly onto how many developers already think about automation. If you've ever written a cron job, you know how to use /loop.

Codex Skills: The Reusable Agent Playbook

Codex Skills approaches the problem from a different angle entirely. Rather than triggers or schedules, OpenAI shipped a system for packaging agent knowledge into reusable, discoverable bundles.

A Skill is a folder with a SKILL.md manifest plus optional scripts and assets. Codex discovers skills via progressive disclosure — it reads metadata first, loads full instructions only when it decides to use a skill. Skills live in .agents/skills/ directories and can be shared across repos.

The multi-agent piece is spawn_agents_on_csv: give Codex a CSV of tasks and it fans out parallel agents with progress tracking and ETAs. Sub-agents get nicknames, approval prompts surface in the UI, and role-labeled handoff context keeps coordination clean.

Combined with Codex's plugin marketplace and 1.6M weekly active users, Skills is OpenAI's bet that the "always-on" future is about standardized agent capabilities rather than triggers or schedules. If agents can discover and compose skills, the triggering mechanism becomes secondary.

The Convergence Pattern

All three tools are converging on the same architectural insight, just from different entry points:

• Cursor starts from events — react to what happens in your dev ecosystem
• Claude Code starts from time — run things on a schedule, poll, and check
• Codex starts from knowledge — make agents smarter so they need less triggering

None of these approaches is "right." They're complementary. A mature always-on setup will probably use all three patterns: event triggers for reactive work, cron for proactive monitoring, and skills for composable agent intelligence.

What This Actually Changes

The shift from prompt-and-monitor to always-on isn't just a UX improvement. It changes what's economically viable to automate.

Before: Automation had to be worth a human's attention to set up. You'd write a GitHub Action or a CI pipeline because the setup cost amortized over hundreds of runs.

Now: An automation can be a single sentence. "Every time a PR merges to main, check for security issues and post findings to #security." That's a Cursor Automation. Or: /loop 30m check if any new issues were filed and triage them. That's Claude Code.

The activation energy for automation just dropped to near zero. This means:

• More automation, finer-grained. Tasks that weren't worth writing a script for become worth a one-line prompt.
• Human attention becomes the bottleneck. When agents can generate work autonomously, the limiting resource is review capacity — not coding capacity.
• The "inner loop" expands. Today's inner loop is write-run-debug. Tomorrow's includes agent-monitor-approve.

Cursor's own data backs this up: they run hundreds of automations per hour, and 30%+ of their PRs come from agents. That's not a demo. That's production.

The Hard Questions

Always-on agents introduce problems that prompt-and-monitor didn't have:

Cost control. A cron job that fires every 5 minutes and burns tokens on every run adds up. Claude Code's /loop fires only while the session is open, which is a natural throttle. Cursor Automations run in the cloud with no such limit. Teams will need token budgets and circuit breakers.

Trust and verification. The Pragmatic Engineer survey already shows trust in AI tools falling even as usage rises. Always-on agents amplify this tension. An agent that runs while you sleep can accumulate errors. The safety mechanisms — sandbox isolation, approval prompts, audit logs — are load-bearing, not nice-to-have.

Noise. An event-triggered agent that posts to Slack on every PR merge will drown a channel in a week. The design challenge isn't "can agents run autonomously" — it's "can they run autonomously without becoming spam." Cursor's risk-based escalation (auto-approve low-risk, flag high-risk) is the right pattern here.

Debugging agents. When an always-on agent does something wrong at 3am, how do you trace what happened? Cursor gives each automation run a sandbox with memory. Claude Code's cron is session-scoped and dies on exit. Both are reasonable constraints, but the observability story is still early.

What to Do Right Now

If you're using any of these tools, here's the practical move:

1. Cursor users: Try one Automation. Start simple — a code review trigger on PR merge, or a Slack-to-issue pipeline. Automations docs.
2. Claude Code users: Upgrade to v2.1.71 and try /loop for something you'd normally poll manually. Deployment health checks are a natural fit. Scheduled tasks docs.
3. Codex users: Create a SKILL.md for your most common workflow. Even a simple one teaches Codex about your patterns. Skills docs.

Don't try to automate everything at once. Pick one task that you do repeatedly and let an agent handle it for a week. See what breaks. That's your real onramp to the always-on future.

The Bottom Line

This week wasn't about any single feature. It was about three companies independently arriving at the same conclusion: the era of manually prompting AI agents for every task is a transitional phase, not the end state.

The end state is agents that run continuously — triggered by events, schedules, or their own accumulated knowledge — with humans as reviewers and architects rather than prompters.

We're not there yet. The cost, trust, and observability problems are real. But after this week, the direction is unmistakable. The only question is how fast we get there.