Routines & automation

Some work should not wait for you to ask. News gets harvested through the morning while you work on something else; health checks run on their own clock; recurring production — briefings, reports, content drafts — repeats on a cadence. Routines are Command Center's answer: scheduled automation where each run is a fresh agent doing one well-defined job.

The honest word for this is unattended, not headless. The scheduler is a service Command Center starts and stops, so routines fire while the app is running and stop when you close it — you do not have to be watching, but the app does have to be open. A slot that passes while the app is closed is not replayed when it reopens; the routine simply runs at its next slot. Cadences worth relying on are therefore cadences that fit the hours you have the app open. Two neighbours behave differently on purpose and are worth knowing about: harvesting tracks each batch's own interval and treats an elapsed one as overdue at start, and the Calendar — for work that belongs to one particular time rather than a cadence — records a firing it could not make instead of quietly moving on.

What a routine is

A routine is a Markdown specification: what to do, which agent posture to do it with, and when to run. A scheduler daemon watches the calendar and, when a routine is due, spawns a fresh agent process for that one run. The agent reads its specification, does the job, writes its output, and exits.

That fresh-process design is the key property. There is no long-lived automation agent accumulating stale context — every run starts clean, reads the current version of its spec and the current state of your workspace, and behaves accordingly. Which also means improving a routine is just editing its file: the next run picks the change up automatically, nothing to restart.

Runs are tracked as jobs with logs on disk. Failures retry with backoff, and a routine that keeps failing disables itself rather than looping — automation that degrades loudly instead of thrashing quietly.

What routines are for

The rule of thumb from the platform's own orchestration doctrine: recurring means routine. One-off bounded work goes to a dispatched agent; a long, watched, multi-part effort becomes a mission; anything on a schedule is a routine.

The flagship example is the intelligence desk: harvesting runs collect news from your configured sources through the day, and writer routines turn the curated material into briefings and ticker items — a pipeline that is simply done each time you look, because routines carried it while you worked on something else. The same machinery runs operational upkeep (health checks, lifecycle housekeeping) and recurring production work.

The scheduler also caps how many routine jobs run at once, so a busy schedule cannot swamp your machine.

Where you stay in control

Routines run unattended by design — so the platform is explicit about where human judgment re-enters:

• Nothing runs until you switch it on. No routine ships scheduled. A routine's own file cannot schedule itself, either: the schedule and its interval live with you, in the Routines view, per routine. A fresh install is a catalog of things that can run.
• You own the schedule. That same view shows every routine, its cadence, and its run history; you enable, disable, and trigger runs from there.
• Outbound is governed by switches you set, not by one universal queue. The newsletter is draft-only by construction — its writer has no way to send, and a broadcast is an explicit click. The email agent is the case where a schedule can reach another person unattended, and only because you granted it a narrow standing authorization; per-message approval is the default it ships with. Both sit under one master stop. The whole model — what an unattended run may do, which switch stops each thing, what gets recorded — is Autonomy & controls.
• Runs are auditable. Every run leaves a log, and outputs land as ordinary files in your workspace — inspectable like anything else agents produce.

A candid note on cost: routine runs spend your own AI subscription like every other agent run, on whichever agent CLI you have configured, and an unattended schedule spends while you are away. Cadences are yours to set — start conservative and widen once a routine has earned trust.

Cadence or a moment?

Routines speak in cadences — every six hours, daily at 09:00, weekly. There is a second scheduler for the other case: work that belongs to one specific moment. That is the Calendar, and the difference is not cosmetic. A routine that is due runs its specification; a Calendar entry that comes due dispatches an agent, either in the background or into a terminal workspace you can watch.

Both run inside the same scheduler process and share the same fresh-process discipline, so neither is a workaround for the other — pick by whether the work has a cadence or a date. What they do not share is how they remember: a routine's cadence is an interval, while a Calendar entry is a stored date with its own record of whether it fired.

Routines, missions, or a one-off agent?

Mixing these up is the most common early mistake — the quick reference above is worth internalizing before you automate anything.

Where to go next

• Routines infrastructure — the routine catalog and scheduler reference
• Calendar — scheduling by date rather than cadence, and the autonomy ladder that governs a dispatched run
• Missions, operations & the fleet — for goals too large for a schedule
• Autonomy & controls — what unattended work may do, and the switches that stop it
• The operator model — the working model those controls serve