The recurring layer
/schedule on your machine · RemoteTrigger in the cloud · the cost conversation · failure triage for long runs
Cowork has two recurring surfaces. /schedule runs tasks on your desktop on a cadence — cron-shaped, machine-on required, full filesystem and connector access. RemoteTrigger fires one-shot agent runs in Anthropic's cloud — no laptop required, but the working tree is ephemeral and writes that aren't pushed somewhere persistent are gone the moment the run ends.
Anthropic's docs show you both syntaxes. They don't tell you which rituals are worth the token spend, how to budget for the spikes, or what to do when a 3-hour run dies at minute 45. That's what this module is.
Five workflows below: the five rituals worth scheduling, the cloud-vs-desktop decision, the cost conversation, failure-mode triage, and the watch/unwatch matrix. Each ends with the same idea in ChatGPT scheduled tasks, GitHub Actions, and Copilot Workspace — so you can compare without committing.
// Anthropic's launch keynote — the /schedule demo. Watch on YouTube →
The recurring starter pack
// audience: anyone past C01Don't schedule things you wouldn't have done anyway. The compounding value is in chores that already exist on a cadence — the daily inbox skim, the weekly status doc, the monthly drift check. These are five real ones we run.
Morning escalations brief
Inbox + Slack + ticket queue, summarised to one short doc on disk before your day starts.
/schedule weekdays 07:30 — Scan my email + Slack DMs + Jira queue for anything tagged escalation or marked priority >= high since 17:00 yesterday. Two-sentence summary per item with sender, recommended next action, and a permalink. Save to ~/morning-brief/{date}.md.Why: this is the single highest-ROI scheduled task because the input already exists and the output is read once. Replaces 15–25 min of triage every morning.
Weekly vulnerability scout
Friday-afternoon CVE digest scoped to your stack. Stages a PR with proposed version bumps.
/schedule Fridays 16:00 — Run the cyberhawk-audit skill against this repo. Cross-reference the past 7 days of NVD + KEV adds with our package manifest. Stage a draft PR with proposed version bumps for any package matching a CVE in the digest. Notify #security on completion.Why: weekly cadence matches the rate of disclosure. Friday gives you the weekend to think before merging Monday.
Hourly KEV / critical-CVE alert
Same scout, faster trigger. Only pings on a real change.
/schedule hourly — Check NVD + CISA KEV for additions in the last 60 min. Filter to packages on our allowlist OR CVSS >= 9.5. If anything matches, post a single-line summary to #security-alerts with the CVE id, affected package, and the upstream advisory link. Otherwise silent.Why: the weekly scout catches the steady state. The hourly catches the news cycle. Two signals, two cadences, one skill.
Daily news digest in your voice
A scheduled task that reads canonical sources, dedupes against yesterday, and ships a finished HTML — not a list of links.
/schedule weekdays 06:00 — Invoke the pickbits-daily-trends skill. Canvass yesterday's signals across the canonical interest feeds, triple-dedupe against the running ledger, apply the human-impact lens to every story, render ~/pickbits-daily/{date}.html. Open a PR to main with the file + the matching social.md set. Notify #content on completion.Why: this is the canonical "agent runs a content pipeline overnight" use case. The cron is one line; the discipline is in the skill it invokes.
Drift check — deps, configs, abandoned tickets
Weekly diff against the version pin file, the IaC tree, and Jira tickets that haven't moved in 30 days.
/schedule Mondays 09:00 — Three checks: (a) any package in package-lock.json that drifted from package.json's range, (b) any Terraform plan that would alter prod resources, (c) any Jira ticket assigned to me, not Done, no comment in > 30 days. Output ~/drift/{date}.md with each section, a one-line verdict, and a "no drift" note where applicable.Why: drift accrues silently. A scheduled Monday review converts "I'll check that later" into "I checked it before the standup."
ChatGPT scheduled tasks: tasks #1 and #4 translate directly — same cadence model, output lives in chat instead of on disk. Tasks #2, #3, #5 need filesystem or repo-anchored access ChatGPT doesn't have.
GitHub Actions: universal cron, runs anywhere. The catch is there's no agent in the loop unless you wire one in. You'd write a runbook script per task instead of a one-line prompt.
Copilot Workspace: no native scheduler. Recurring work happens through GitHub Actions invoking Copilot's API.
Two recurring surfaces, one decision
// audience: anyone past their third schedule/schedule runs on your machine. RemoteTrigger runs in Anthropic's cloud — you fire-and-forget, the agent works in a clean checkout, results come back as messages, comments, or files in a connected system. The difference matters when your laptop is closed.
The trap: RemoteTrigger looks like a free upgrade until you realise the filesystem doesn't persist. We learned this the hard way — a cloud-fired pipeline that wrote 12 HTML files looked successful on the run summary, but nothing landed in the repo because the agent's working directory evaporated after the run. Notion entries it wrote in the same task survived because Notion is a connector, not a filesystem.
The rule:
- If the artifact lives in a connector (Slack message, Notion page, Drive file, Jira comment), either surface works. Pick by machine-availability.
- If the artifact has to land on disk in your repo, use
/schedule. Or have the RemoteTrigger run end with agit pushto a connected branch. - If the trigger is event-shaped (a Slack post, a webhook, a button), use RemoteTrigger.
/schedulecan't react to events.
ChatGPT: scheduled tasks run cloud-side already, so there's no equivalent split. The trade-off is reversed — no local FS option at all.
Codex (cloud): always cloud-side. Branch-scoped persistence; results land as a PR.
GitHub Actions: the universal cloud cron. To get the same agent loop you'd invoke an LLM API from inside the workflow — works, but you give up the conversational task panel.
What recurring agents actually cost
// audience: anyone with a finance teamOne-line schedules feel free until the monthly bill arrives. Three places where cost compounds:
- Long web research. A digest task that reads 30 articles can run 6–10× the tokens of one that reads 5. Hard-cap source count in the prompt.
- Big spreadsheet builds. Multi-tab xlsx with formulas reasons over the whole sheet on each cell write. Single-tab outputs run a fraction of the cost.
- Recursive sub-task spawning. An agent that says "for each row, do X" can spawn 200 sub-tasks before you notice. Cap the fan-out in the prompt: "process at most 25 rows per run, queue the rest for the next."
Rough order-of-magnitude per scheduled run (Pro plan, Opus, 2025-26 pricing — check your dashboard for current numbers):
- Morning brief (5–10 emails summarised): $0.05–$0.20 per run. Daily = ~$3/month.
- Weekly CVE scout (one repo, 5 advisories cross-referenced): $0.40–$1.20. Weekly = ~$3/month.
- Daily news digest (10 sources, 5 stories, rendered HTML + 8 social variants): $2–$5. Weekdays = ~$60/month.
- Excel build (multi-tab, formulas, conditional formatting): $1–$3. Per-build, not scheduled.
The signal to watch isn't the per-run cost — it's the slope. A schedule that doubles in cost week-over-week is doing something you didn't intend (usually fan-out). Cowork's per-task metering is in the task summary; group spend limits live in admin (covered in C05 Govern).
The set-once guardrail: add an explicit budget line to every scheduled prompt. Hard cap: max 25k tokens per run. If you hit the cap, stop, save partial output, post "budget hit at step N" to #ops. The agent will obey it.
ChatGPT scheduled tasks: token cost is hidden behind the Plus/Team subscription — there's no per-task meter exposed to end users. Visibility is worse, but so is the surprise.
GitHub Actions: compute cost is on you; LLM cost depends on which API you call. The line items are clearer because they're already separated.
Five failure shapes — and the recovery
// audience: anyone running tasks > 30 minLong scheduled tasks fail differently than chat does. The recovery isn't "ask the agent to fix it" — it's "stop, diagnose the surface, restart from the last known good state." Five shapes you'll meet:
- Connector OAuth token expired mid-run. Slack, Drive, Gmail tokens refresh; if the refresh fails the run stalls. Settings → Connectors → re-auth, then re-issue the same scheduled run manually. The cron picks up the next slot cleanly.
- Context cap hit. A task reads more than the model can hold. Either narrow the input (cap source count, scope the folder tighter) or switch the prompt to a streaming pattern: "process one source, write to disk, move to the next."
- Partial output written, agent stopped. The first 7 of 10 expected files are on disk. Don't re-run the whole task — resume from the last known good output: "~/morning-brief/2026-05-10.md already has sections 1–7. Continue from section 8."
- Stuck in a tool loop. Same connector failing the same call. Stop the run from the task panel. Check Settings → Logs for the offending invocation. Re-prompt avoiding that connector path, or file a trace as feedback.
- The repo moved under the run. Especially with RemoteTrigger and a bot that pushes during long sessions — non-fast-forward rejection on the final git push. Recipe:
git stash && git pull --rebase && git push && git stash pop. Combine-block conflicts in render scripts compose cleanly.
The resume prompt template — works for most partial-output failures:
Resume the {scheduled-task-name} run. Last known good output: {path-or-id}. Stop at step: {step-where-it-died}. Pick up from the next step. Do not redo prior work. Same constraints as the original prompt. Same write paths.This is faster than re-running the whole task and avoids the duplicate-write problem.
All five failures show up in Codex, ChatGPT scheduled tasks, and any agentic loop. The mechanics of recovery are different: Codex re-runs the whole branch on retry (no partial-output concept), ChatGPT scheduled tasks restart from the prompt on the next cadence slot (no resume). Cowork is the only one where you can hand-edit the prompt with a "pick up from N" and the agent honours it.
The watch / unwatch 2x2
// audience: anyone with > 3 schedules runningThree schedules is the inflection point. Below that, reading every summary is fine. Above, you need a discipline — or you stop reading any of them and the value evaporates. Two axes: how often the task surfaces something anomalous, and how reversible the agent's actions are.
How to wire "ping on anomaly": end every scheduled prompt with a self-check. "If nothing changed since the last run, write only a one-line OK. If anything changed, write the full summary and post to #ops." Cowork's scheduled tasks will honour both branches; you stop drowning in 80%-identical daily emails.
Common mistake: watching everything because it feels responsible. After two weeks you skim summaries on autopilot and miss the one that actually mattered. Calibrate — the agent's job is to filter, not to copy you on the unfiltered stream.
The matrix is platform-agnostic. The Cowork-specific piece is that the agent can read its own previous output before deciding whether to ping — "compare this run to yesterday's digest" is a one-line addition to any prompt. ChatGPT and Codex can do similar with explicit state passing.
The honest read
// audience: everyone/schedule is good for chores that already happen on a cadence. It's not good at:
- Tasks where every step needs human approval. If the run-summary review is going to take longer than doing the work, you're using the wrong shape. Use chat with manual confirmations.
- Anything you'll do once and forget. Scheduled tasks are an artifact you maintain. One-off work is cheaper as a chat thread.
- High-stakes irreversible actions. A scheduled task that posts to a public channel, fires a payment, or modifies prod data — the matrix in C01 still applies. Use Cowork to draft on schedule, and have a human execute.
- Event-shaped triggers. "When a customer posts in #support…" isn't a cron, it's a webhook. Use RemoteTrigger or wire a Hog Flow on PostHog / a Zapier trigger.
The right mental model: schedules are for the boring middle — recurring work you already do that produces a known shape of output. Save the watch-vs-trust matrix from C01 and apply it before you flip the switch on a new ritual.
You run scheduled agents. We help you wire the rest.
Module C02 of five in the Cowork for IT Pros track. If you want this built on your team's actual stack — with your connectors, your rituals, your governance — our advisory engagements are scoped for exactly that.
← Back to Cowork track ← C01 · Delegate C03 · Connect →