Claude Routines: What They Are, Their Limits, and a Twitter (X) Watch Routine

Anthropic's documentation defines a cloud scheduled task, formerly a routine, as "a saved Claude Code configuration: a prompt, one or more repositories, and a set of connectors, packaged once and run automatically." It executes on Anthropic-managed cloud infrastructure, or on an organization's self-hosted environment when routed there. The @claudeai account announced the feature on April 14, 2026 as "routines in Claude Code", now in research preview, and the docs still carry the research-preview note.

Each routine is a full Claude Code session. A run clones the repositories you picked, runs shell commands, uses skills committed to the repo, and calls the connectors you included. You do not choose a permission mode: on Anthropic's cloud a run starts in auto mode, where a classifier allows or blocks actions that would otherwise wait for approval. A run still stops and waits if an action matches an ask rule or blocks pile up past auto mode's thresholds.

It runs as you. Routines belong to your individual claude.ai account, are not shared with teammates, and their runs count against your account's usage. Commits and pull requests carry your GitHub user; Slack messages or Linear tickets created through connectors use your linked accounts.

Where the old name survives. The docs list five places that still say routine. They all point to the same feature:

Who can use it. The docs list Pro, Max, Ultra, Team and Enterprise plans. Team and Enterprise Owners can switch the feature off for everyone with the Scheduled tasks (Was Routines) toggle under Organization settings, Capabilities, Remote sessions; when it is off, existing routines stop running. /schedule also needs a claude.ai subscription login: with a Console API key, a cloud-provider login (Bedrock and similar) or ANTHROPIC_API_KEY set in your shell, the CLI hides the command.

Claude Code has three ways to run something on a timer, and the docs publish a comparison. The short version: routines run in the cloud and need nothing from your machine; Desktop scheduled tasks run on your computer with your files; /loop repeats a prompt inside a session you keep open.

What the table hides. /loop tasks are session-scoped and recurring ones expire seven days after creation (they fire one last time, then delete themselves), and a session holds at most 50. Desktop tasks only fire while the app runs and the computer is awake; a run the computer sleeps through is skipped. A routine has neither problem, but it cannot read anything on your disk and it cannot run more often than hourly.

Which one for an X watch. If you need checks every few minutes while you work, /loop or a Desktop task is the only Claude-side option, and for true real-time alerts a push rule or a plain cron job is cheaper than a model run. For an hourly or daily digest that must keep going while you sleep, a routine is the right tool, and that is the case we build below.

Routines spend your Claude subscription usage the same way interactive sessions do (check it at claude.ai/settings/usage). On top of that, each way of starting a run has its own hourly cap, and none of these caps has overage:

When you hit the subscription limit, organizations with usage credits turned on keep running routines on metered overage; without them, further runs are rejected until the usage window resets. While a subscription is paused, routines are put on hold, and you switch them back on afterwards.

Schedule rules. Presets cover hourly, daily and weekly; for anything else, choose Custom in the edit dialog and enter a cron expression such as 0 */2 * * *. Expressions that run more often than once an hour are rejected. A five-field expression is read in UTC (0 9 * * 1-5 is 9:00 AM UTC on weekdays) unless it starts with a CRON_TZ= prefix. A run scheduled exactly on the hour can start several minutes late, so the docs suggest a few minutes past, such as 9:07. One-off runs turn themselves off after firing and show as Completed.

GitHub access. If your GitHub connection is missing or expired when a run is due, the routine skips runs for up to 72 hours, then turns itself off. GitHub webhook events also have per-routine and per-account hourly caps; events past the cap are dropped.

Cloud machine limits. Anthropic-hosted sessions run with roughly 4 vCPUs, 16 GB of RAM and 30 GB of disk. A foreground command waits 2 minutes by default (up to 10 on request), and a command that runs past its timeout moves to the background for up to 30 more minutes. A setup script that takes longer than about five minutes is not cached.

Run outcomes are about the session, not your goal. The History list shows Succeeded, Failed or Cancelled, and the docs warn that Succeeded only means the session ended without Claude Code reporting a failure. A blocked network request or a missing connector shows up inside the transcript, not on the row, so read the first few runs end to end.

An API trigger gives a routine its own URL. You add it on the web (not from the CLI): edit the routine, click + in the Trigger row, choose API, copy the Fire URL and click Generate token. The token is shown once, is scoped to triggering that one routine, and has no read access. Regenerate rotates it; deleting it removes the API trigger.

The request is a plain POST. Per the platform.claude.com API reference, anthropic-version is required and the endpoint accepts every version from 2023-06-01 on; an older beta header that early integrations send is still accepted. The optional text field (up to 65,536 characters) carries run-specific context. It is not parsed: JSON you send arrives as a literal string. The call returns as soon as the session exists; it does not wait for the run.

Fire text is untrusted by design. The text value reaches Claude wrapped in a <routine-fire-payload> block labeled as untrusted data, so Claude will not follow instructions inside it unless the routine's saved prompt explicitly says to act on that block. Anyone with the token can send text, which is why the wrapper exists.

Errors you will see. 400 for a missing anthropic-version, oversize text or a paused routine; 401 for a missing or wrong token; 403 when the account lacks access; 404 for an unknown routine; 429 when an hourly fire cap is reached, with a Retry-After header. The routine id in the URL starts with trig_, and the token with sk-ant-oat01-. This endpoint is billed as Claude Code subscription usage and is not part of the Claude Platform API surface, so the Anthropic SDKs do not wrap it.

The worked example is a small repository with one script, watch.py (full code at the end of this page), plus a routine whose prompt tells Claude to run it, read the digest, post it to Slack through the Slack connector if there is anything new, and save its state. The script does the deterministic part (calling the X search, deduplicating, writing a digest); Claude does the judgment part (summarizing what changed and deciding whether it is worth a message).

Step 1: the repository. Create a GitHub repo, for example x-watch, containing watch.py. The script calls GET https://api.twitterapi.io/twitter/tweet/advanced_search with queryType=Latest and a since_time:<unix seconds> operator (the operator form the TwitterAPI.io docs specify; since: dates are not supported there), follows has_next_page and next_cursor, and writes digest.md plus last_seen.json. Reading X this way needs no X account: only a TwitterAPI.io key.

Step 2: the environment. The Default cloud environment uses Trusted network access, which only allows a list of package registries and common development domains; requests to other hosts fail with 403 and x-deny-reason: host_not_allowed. Create an environment (say x-watch), set Network access to Custom, add api.twitterapi.io under Allowed domains and tick the option that keeps the default package-manager list, so pip install requests still works.

Step 3: the key, as a network secret. Do not paste the key into environment variables: the docs say those are visible to anyone who uses the environment. Add a network secret instead: Allowed websites api.twitterapi.io, and in Custom headers change the header name from Authorization to X-API-Key and clear the Bearer prefix, then paste the key as the value. Anthropic's agent proxy attaches the header after each request leaves the session VM, so the key never appears in the session's variables or files. That is why watch.py only sends its own header when TWITTERAPI_IO_KEY is set locally.

Step 4: state between runs. Every run starts from a fresh clone of the default branch, so a file written in one run is gone in the next unless it is pushed. The prompt below keeps last_seen.json on a claude/x-watch-state branch: Claude checks it out, runs the script, commits the new state and pushes. Without state, an hourly window plus the docs' warning that on-the-hour runs can start several minutes late would leave gaps or duplicates.

Step 5: the routine. Create it at claude.ai/code/routines (New task, or New routine on older accounts) or run /schedule in the CLI and describe it. Pick the repo and the x-watch environment, remove every connector except Slack (all connected connectors are included by default and Claude can write with any of them), choose a model, and set a Custom cron of 7 * * * * so it runs at minute 7 of every hour. Then click Run now once and read the transcript.

Hourly is the fastest a routine can go, so the useful question is how much an hourly run finds. We measured two very different terms. The niche query (routines and scheduled tasks for Claude, reposts excluded) returned 420 posts from 342 authors across about 4,669 hours since the April launch: 0.09 posts an hour on average. In 91.7% of those clock hours there was nothing at all, and the busiest single hour had 3 posts. The broad query "claude code" produced 300 posts in 1.04 hours, about 289 an hour, from 237 authors.

Niche terms: the model run is the cost, not the data. In the last 30 days of the sample, only 7.4% of hours had any matching post (59 posts, about 1.97 a day). An hourly routine would spend most of its runs (and your subscription usage) discovering that nothing happened. For a term like this, a daily or every-6-hours schedule loses almost nothing; the prompt's "if 0 new posts, stop" rule keeps empty runs short.

Broad terms: plan for pagination and a digest. At about 289 posts an hour, each run needs 15 requests of 20 posts. Before your first payment, TwitterAPI.io allows 0.2 requests per second, so those pages take over a minute; after the first payment the limit is 20 per second. Do not hand Claude 289 raw posts: let the script rank and trim (it keeps the top 15 by likes), because each post Claude reads is model context you pay for in usage.

Who is posting. 47% of the "claude code" posts were replies and the median post had 15 views and 0 likes, so a likes or views floor in the script removes most noise. The niche sample was 63% English and 17% Japanese, so add lang:en to the query if your digest should be English only.

Yes, steadily but at low volume. The niche sample peaked in the first full month after launch with 104 posts, fell to 28 in September and came back to 59 in October. 37% of these posts carried a link (usually to a tutorial or a repository) and the median post drew 760 views.

On the official side, scheduling is a small but high-performing share of Anthropic's posting. Of the 200 most recent @claudeai posts, 3 were about routines or scheduled tasks (1.5%): the February 2026 Cowork scheduled-tasks post, the April 2026 routines launch, and the June 2026 Code with Claude Tokyo post on scheduled deployments in Claude Managed Agents. Their median was 18,202 likes and 4,631,687 views, against 10,989 likes and 2,127,444 views for the account's other posts. None of the 100 most recent @AnthropicAI posts were about the feature.

Why this matters for your routine. If you watch a vendor's own launch, the official post is one item a year; the conversation around it is what moves. A routine that watches the term (not the account) catches the tutorials, complaints and workarounds that follow a launch, which is exactly the slow, steady stream an hourly or daily digest handles well.

There are two bills. The model side is your Claude plan: routine runs draw down subscription usage like interactive sessions, with metered overage only if your organization turned on usage credits. Anthropic does not publish a per-run price, so the honest way to size it is to run the routine a few times and watch claude.ai/settings/usage. Our Claude Code pricing guide covers the plans themselves.

The X data side is easy to compute. TwitterAPI.io bills 15 credits per tweet returned, which is $0.15 per 1,000 tweets, with a 15-credit minimum per request, so a run that finds nothing costs $0.00015 and a full 20-post page costs $0.003. You pay only for the data returned; credits you buy never expire, and new accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days).

Reading the comparison. The official figure uses the pay-per-usage rate card at docs.x.com/x-api/getting-started/pricing: $0.005 per post read, $0.010 per user read, capped at 3 million post reads per monthly billing cycle with Enterprise above that, plus $20 in credits on a first card purchase and a match of the first auto-recharge up to $50. Per 1,000 tweets that is $5 against $0.15, about 33x. For a busy term the gap is the whole budget; for a niche term both are pocket change and the Claude usage dominates.

If the routine should also post to X. Writing is a separate, authenticated flow on TwitterAPI.io: one /twitter/user_login_v2 login ($0.10, with a proxy you supply) returns login_cookies, then each post such as /twitter/create_tweet_v2 costs 60 credits ($0.0006), billed per HTTP 200 call. Every write acts as that account, so X can rate-limit, lock or suspend it; keep a human pace, expect to log in again when the session expires, and keep the routine's prompt to drafting, not mass posting.

Question. How much would an hourly Claude routine find on X for a niche new term and for a broad term, what would the X data cost, and how much do the official Claude accounts post about the feature?

Accounts and queries. Timelines of @claudeai (200 posts) and @AnthropicAI (100 posts) via /twitter/user/last_tweets. Two /twitter/tweet/advanced_search queries with queryType=Latest: posts mentioning "claude routines", "claude code routines", "claude scheduled tasks" or "claude code scheduled" (reposts excluded), and posts mentioning "claude code" (reposts excluded).

Window and sample. Most recent posts at collection time, collected in 2026: 1,020 posts in 52 requests, an X data cost of about $0.15. The niche search ran until it had no further pages (420 posts back to the April launch); the broad search was capped at 15 pages, a slice of about one hour. Hourly figures bin posts by UTC clock hour; the "claude code" monthly figure extrapolates the observed hourly rate across 720 hours.

What the sample cannot show. Search returns what X's search index exposes for the query, not every post that ever used the words; posts that only show a screenshot are missed. A one-hour slice of a broad term ignores daily and weekly swings. The keyword match on official posts is a text match, checked by hand. Claude model usage per run is not measured here.

Privacy. Aggregates only. The two named accounts are Anthropic's official organization accounts; search results came from private individuals, so their raw pages were never published and the committed sample is de-identified (no ids, links, text or handles).