The most consequential feature in Claude Code's March 2026 release is not voice mode or the expanded context window. It is /loop — a command that turns Claude Code into a background worker that executes tasks on a recurring schedule, similar to cron but with the full reasoning capabilities of an agentic AI system.
The command syntax is simple: /loop 5m /review-pr runs the PR review skill every five minutes. /loop 30m "check the deployment status and alert me if any services are unhealthy" runs a natural language task every thirty minutes. The default interval is ten minutes if unspecified.
This changes Claude Code from a tool you interact with to a tool that works alongside you — monitoring, reviewing, and maintaining your development environment while you focus on other work.
What /loop Actually Does
Under the hood, /loop maintains a persistent Claude Code session that wakes on the configured interval, executes the specified task, and returns to sleep. The session maintains context across iterations — if the deployment check at 2:00 PM found an issue, the check at 2:30 PM has awareness that the issue was previously identified and can report whether it persists, worsened, or resolved.
The context persistence is what distinguishes /loop from a simple cron job that runs a script. A cron job executing curl health-endpoint && notify performs the same check identically every time, with no awareness of history or trends. A /loop task accumulates understanding: it notices when error rates are trending upward, recognizes recurring patterns across iterations, and adjusts its reporting based on what it has already told you.
The practical constraint is that /loop runs within a single Claude Code session. When the session ends — terminal closed, machine restarted, explicit cancellation — the loop stops. This is a local-first design: the scheduling runs on your machine, not on a cloud service. There is no daemon, no background process surviving terminal closure, no persistent infrastructure. It is as simple as it sounds, with the limitations that simplicity implies.
Use Cases That Actually Work
The use cases that have emerged as genuinely useful in the weeks since /loop shipped fall into three categories:
Continuous PR Review
/loop 10m /review-pr
This checks your repository for new or updated pull requests and runs Claude Code's review skill on them. For teams where PR review is a bottleneck — and it is one of the most consistently cited bottlenecks in developer surveys — continuous automated review provides a first-pass analysis that catches common issues before a human reviewer looks at the PR.
The value is not replacing human review. It is reducing the time humans spend on mechanical review tasks (missing error handling, inconsistent naming, unused imports, test coverage gaps) so that human review time is spent on architectural and design decisions that require human judgment.
Deployment Monitoring
/loop 5m "check the health endpoints for staging and production, compare response times to the baseline, and notify me if anything looks off"
Claude Code can execute curl commands, parse JSON responses, compare values across iterations (because it maintains context), and produce human-readable summaries of what changed. This is not a replacement for proper monitoring infrastructure — but for individual developers who want lightweight awareness of their services' health during a deploy or after a release, it fills a gap between "no monitoring" and "setting up Datadog."
Test Suite Watching
/loop 15m "run the integration test suite and tell me if any new failures appeared since the last run"
During active development on a shared branch, knowing when someone else's changes broke the tests — and specifically which tests and when — is valuable feedback. /loop provides this without requiring the developer to remember to run the tests manually or to set up a CI pipeline for a branch that is still in active development.
The Design Decision: Local, Not Cloud
Anthropic made a deliberate choice to implement /loop as a local terminal feature rather than a cloud-hosted scheduled execution service. This aligns with Claude Code's design philosophy but has real tradeoffs.
| Property | /loop (Local) | Cloud Scheduled Agents |
|---|---|---|
| Setup | One command | Service configuration, auth, deployment |
| Persistence | Ends with terminal session | Runs indefinitely |
| Cost | Uses your Claude Code subscription | Separate compute + API costs |
| Access | Your machine's tools and files | Cloud environment only |
| Reliability | Dependent on your machine being on | Always available |
| Context | Your full local environment | Limited to cloud-accessible resources |
The local approach is right for developer-personal tasks: monitoring your services, reviewing your PRs, watching your test suite. It is insufficient for team-level automation that needs to run reliably regardless of whether any individual developer's machine is on.
For team-level scheduled agent work, Anthropic offers separate infrastructure (Claude Code Channels, remote triggers). /loop is explicitly scoped to the individual developer's terminal session — a design choice that keeps it simple and avoids the infrastructure complexity of persistent scheduling.
Combining /loop With MCP Tools
The value of /loop compounds when combined with MCP tool integrations. A loop task is not limited to what Claude Code can do natively in the terminal — it has access to whatever MCP servers are configured in the current environment.
With GitHub MCP tools connected: /loop can monitor PRs, check CI status, review issue activity, and summarize what happened on the repository since the last check.
With Slack MCP tools connected: /loop can summarize unread messages in relevant channels, draft responses to questions, and notify you of messages that need attention.
With database MCP tools connected: /loop can run health queries, check for anomalous data patterns, and monitor table growth rates.
The MCP integration turns /loop from a code-focused monitoring tool into a general-purpose background worker that can observe and act across any system with an MCP interface. This maps to the personal agent stack pattern: a collection of connected tools that an agent uses to handle the work between your focused tasks.
What This Means for Desktop Agent Platforms
/loop demonstrates a pattern that desktop agent platforms like Neumar can adopt and extend: scheduled agent tasks that run within the user's local environment, with access to local tools and persistent context across iterations.
Neumar's architecture — with MCP tool integration, long-term memory, and workspace-scoped execution — is well-positioned for this pattern. A Neumar agent that runs a scheduled task every fifteen minutes has access to the full MCP tool ecosystem, the memory of previous sessions, and the workspace context that informs its actions. The result is a background worker that is not just executing a script but maintaining an evolving understanding of the project's state.
The combination of /loop-style scheduling with Neumar's persistent memory is particularly powerful: the agent does not just remember what happened in the current loop session. It remembers what happened across all sessions, providing continuity that a terminal-scoped tool cannot match.
Neumar supports MCP-based tool integration and long-term memory that complement scheduled agent tasks. The pattern established by Claude Code's /loop command — local, context-aware background execution — extends naturally to Neumar's desktop agent architecture.