Async Agent Routines.
Recurring work, audited.
Once your synchronous loop is reliable, the next move is turning the workflow you ran by hand into a routine that runs on a trigger — with a checkpoint artifact, a verification gate, and a human approval line you can review.
Six pieces. Name each one before you let it run.
If any of the six is missing or vague, you don't have a routine — you have a cron job that will quietly do the wrong thing. Write each one down before the agent runs unattended.
Trigger
The exact event that starts the routine. A cron schedule, a webhook from GitHub or Linear, a row inserted in a table, a Slack command. Write the trigger spec down — when it fires, what payload it carries, what should make it skip.
Repo & context
The repo, the docs, the database view, the past-week transcripts — whatever the agent needs to read to do the work. Pin it in writing. Context that drifts week to week is the most common cause of routine quality decay.
Allowed actions
What the agent is allowed to do, by name. Open a PR, post a draft to a Slack DM, update a row, write a file in /proposed/. Anything not on the list, it can't do. This is where you decide how much trust the routine gets.
Checkpoint artifact
The single file or message the routine produces every run. A markdown diff, a draft email, a CSV, a PR with a title and body. One thing you can open and read. If you can't point at the artifact, you can't audit what the routine did.
Verification gate
The check that runs before the artifact reaches you. Lint, tests, a self-evaluation prompt, a schema check on the JSON it produced. Cheap, deterministic, and run every time. Failure stops the routine and pings you.
Human approval line
Where you sit in the loop. Approve the PR, click send on the draft, mark the row reviewed. The routine never crosses this line on its own. The approval line is the difference between an agent you trust and an agent you have to babysit.
What this looks like in real work.
Each one is a routine I'd actually ship. The shape is the same six pieces — trigger, context, actions, artifact, gate, approval — applied to a specific workflow you probably already run by hand.
Weekly changelog monitor
Trigger: Monday 9am cron. Context: Anthropic, OpenAI, Gemini, Vercel AI SDK release feeds. Actions: fetch the feeds, compare against last week's approved digest, and draft two recommended updates. Artifact: a markdown diff posted to a private Slack channel. Gate: every recommendation needs a source link and a "why this changes the workflow" note. Approval: you reply with the two items worth pulling into the course or harness.
PR review + patch notes
Trigger: GitHub webhook on PR opened. Context: the diff plus CLAUDE.md and AGENTS.md. Actions: inspect changed files, run the repo's check command, and draft patch notes. Artifact: an inline review with suggested patch and a one-paragraph summary. Gate: no finding ships without a file, line, or failing command attached. Approval: you accept, edit, or close the suggestions.
Sales-call note → CRM update
Trigger: new transcript saved. Context: the transcript plus the account record. Actions: extract commitments, draft the follow-up, and propose CRM field updates. Artifact: a follow-up draft, a next-step checklist, and proposed CRM field updates. Gate: required CRM fields must pass schema validation and each commitment needs a transcript quote. Approval: you send the email and click apply on the field updates.
Docs freshness audit
Trigger: first of the month. Context: the docs tree plus the recent product changelog. Actions: compare shipped changes to docs, mark stale sections, and draft edits. Artifact: a stale-docs list with proposed edits as a draft PR. Gate: link check, docs-only diff, and one changelog reference per edit. Approval: you review section by section, merge or comment.
Lightweight pre-deploy QA
Trigger: CI job on merge to main. Context: the diff, the test output, the deploy preview URL. Actions: open the preview, run the smoke path, capture failures, and summarize risk. Artifact: a go/no-go note with the three things to spot-check. Gate: build green, preview reachable, and no smoke-path failures. Approval: you click deploy, or you don't.
Competitive source watcher
Trigger: Friday afternoon cron. Context: a short list of competitor blogs, Substacks, and release pages. Actions: fetch the sources, ignore unchanged pages, cluster real changes, and draft a note. Artifact: a one-page brief — what shipped, what changed, what's worth a closer read. Gate: every claim needs a source URL and anything without a date goes into "needs review." Approval: you decide what to write up or react to.
Routines come after the synchronous loop, not before.
Don't put a workflow on a cron until you've run it by hand three times and the diff looks the same every time. The harness teaches the synchronous loop; routines turn that loop into something always-on.
Start with the harness
If you haven't yet, grab the harness. AGENTS.md, CLAUDE.md, five slash commands, scope filter. Get the synchronous loop reliable first.
Run the scope filter
Use the scope filter on the workflow you'd put on a trigger. If the synchronous version can't ship in 14 days, the async version isn't ready either.
Then make it a routine
Once you trust the manual version, write the six pieces above for your workflow. The artifact and the approval line are where most operators cut corners — name them first.
I'll scope and build it with you.
Routines are exactly what the consulting and coaching engagements are for. Bring one repeated workflow — sales note review, weekly brief, docs audit, QA pass. We'll write the six pieces, ship the v1, and put it on a trigger you can audit.