How to Schedule a Recurring AI Task That Runs Weekly

10 min read

Make this article actionable

Send the article context into Vife Agent and turn it into a plan, checklist, or draft you can keep working on.

Open in Agent

Every Monday at nine, someone opens the same five pricing pages, copies numbers into a spreadsheet, and writes three short paragraphs about what moved. It takes forty minutes, the result is never quite the same twice, and it is exactly the kind of work that should run on a schedule instead of on a person's calendar.

Assistant products are moving in that direction. On 17 November 2026, Google said Tasks in Gemini became free of charge in six countries — the U.S., Japan, Korea, Canada, Australia and India — with advanced features rolling out "starting in the U.S." (Google blog). The same post says Gemini is "designed to pause and check with you before critical steps," and that Google has "tested tasks extensively to minimize mistakes" but has not "eliminated all of them." Five days earlier, Google introduced Gemini 4 Hydrogen for "everyday coding and agentic workflows," claiming "tighter instruction following and fewer fabricated claims" (Google blog). Those are vendor claims about their own products, not a promise about your job.

The churn is the second reason to be careful. The LLM Stats release timeline lists Qwen4-Max on 16 November 2026, GPT-6.2 Astra and Sol on 17 November, and Gemini 4 Neon on 18 November (LLM Stats). Whatever runs your weekly digest this month may be a different model next month, so the job has to be written so that swapping the model changes nothing about what the output must contain.

A recurring task fails differently from a one-off task

When you delegate something once, you read the answer immediately. When you schedule it, four things change.

  • Nobody is watching. The output lands at 08:00 on a Monday and waits. A plausible-looking wrong number can sit there for days.
  • Runs accumulate. Week one's mistake becomes week two's baseline unless you store what was actually true.
  • Sources drift silently. A pricing page changes layout, a feed stops updating, a page moves behind a login. The task keeps producing output either way.
  • Cost multiplies quietly. A job that costs a little once costs that amount fifty-two times a year, plus the reading time.

So the design goal is not "a good first run." It is a job whose bad runs are obvious, cheap, and harmless.

Mid-read shortcut

Turn the useful parts into next steps

Vife Agent can convert this guide into a prioritized workflow with tasks, risks, and reusable prompts.

Create a brief

Step 1 — Write the job as one sentence with five slots

Most scheduled tasks are written as a topic: "monitor competitors." That is not a task, it is a mood. Write it as a contract instead, filling five slots.

Every Monday at 08:00 Asia/Singapore, read these five URLs, compare each value against the last run recorded in state.md, and write a 150-word digest with a four-column table to outputs/pricing-digest.md. If a source cannot be read, mark it "not checked" and do not estimate. Never send, publish or buy anything.

The five slots are cadence and timezone, fixed inputs, comparison baseline, output contract, and the hard stop. Leave any one out and the run fills the gap with its own judgment — which is the part you were trying to control.

The hard stop belongs in the text, not in the product

Google's post describes an assistant that pauses before critical steps and lets users set routine actions to "Always allow." That is a sensible default, but defaults differ between tools and can change. If your job must never send an email on its own, say so in the job text, and keep the sending step outside the schedule entirely.

Step 2 — Pin the trigger and name the timezone

"Monday morning" is ambiguous in a way that costs you a week. Name the timezone inside the job sentence, not in a settings field you will forget. If the runner's timezone and the reader's timezone differ, a job can arrive Sunday evening and look like it failed.

Two practical rules:

  1. Run after the sources settle. If a dashboard refreshes overnight, schedule the read after that, not before.
  2. Run before the meeting, not minutes before. A digest that arrives at 08:55 for a 09:00 review gives you no time to correct a bad row. A day earlier does.

Step 3 — Freeze the input list

Letting the assistant choose its own sources each week is how you get a digest that is never comparable to the last one. Keep a plain list: one exact URL per line, plus a short note on what to read there.

text
# pricing-sources.md (last edited 2026-11-19) https://example.com/pricing -> read the three plan prices, monthly, USD https://example.com/changelog -> read the newest entry date and title https://status.example.com -> read current incident state only

Add a source deliberately, with a date and a one-line reason. Remove one the same way. The list becomes the audit trail for why a number appeared.

Step 4 — Write the output contract

The output contract is what makes a run checkable in ten seconds instead of ten minutes. Specify:

  • Shape — heading, one table, at most three bullets. Not "a summary."
  • Length cap — a number of words, not "concise."
  • Sourcing per row — each number carries the URL it came from and the date it was read.
  • No new metrics — the run may not introduce a column that was not in the previous output.
  • The empty case — what "nothing changed" looks like. One line, not a paragraph of filler.

A contract like this also makes the next step possible.

Step 5 — Keep a state file and set a change threshold

Without stored state, a weekly job either repeats itself or invents movement. Keep one small file the run reads and writes:

text
2026-11-12 | plan_a | 49 | 49 | unchanged 2026-11-12 | plan_b | 99 | 99 | unchanged 2026-11-19 | plan_a | 49 | 59 | +20.4%

Then set a threshold in the job text: report a row only if it moved by more than a stated amount, or if the source gained a new entry. Everything else collapses into the one-line empty case. This is the difference between a digest people read and a digest people filter to trash.

The threshold also catches fabrication. A run that reports a 12% move when the state file says nothing moved is a run you should discard, not edit.

Step 6 — Draw the approval line before the first run

Split the job into reads and writes, and be explicit about which side of the line each step sits on.

StepSide of the line
Fetch pages, compute change, draft the digest
unattended
Write the digest file and update state
unattended
Send the digest to a list, publish it, change a live page
human
Pay, book, delete, or accept terms
human

For the first month, run in draft-only mode even for the steps you plan to automate later. You are testing the contract, not the autonomy.

Step 7 — Run it supervised twice

One good run is not evidence. Do this instead:

  1. Run it once while you watch, and produce your own version by hand in parallel. Count the differences, not the impressions.
  2. Fix the job text, not the output. If a row was missing a source link, the contract was underspecified. If a number was wrong, the source note was too vague.
  3. Check the state file after the run. If it was not written correctly, week two has no baseline and the whole design collapses.
  4. Run it a second time on the normal schedule, then compare the two outputs for consistency of shape.

Only after that should the job run without you reading it the same day.

Step 8 — Design the failure path

Write down what happens when things break, because they will:

  • A source is blocked or paywalled → "not checked," with the URL. Never an estimate.
  • A source returned an empty page → treat as blocked, not as "price removed."
  • The run produced nothing → say "no change" only if every source was read; otherwise say "partial."
  • A timeout → one retry, then report the failure and leave the state file untouched.

A failed run that says it failed is worth more than a successful-looking run that guessed.

Step 9 — Audit once a month

Fifteen minutes, four questions:

  1. Are these still the right sources, or has one become irrelevant?
  2. Is the threshold still catching the changes you care about?
  3. Is anyone actually reading the output? If not, delete the job rather than let it run.
  4. What does it cost per run, multiplied by runs per month?

Checklist before you schedule it

  • The job is one sentence with cadence, timezone, inputs, baseline, output and hard stop
  • Every source is an exact URL with a note on what to read
  • The output has a fixed shape, a word cap and a per-row source link
  • The state file is written and read by the job itself
  • A change threshold is stated in numbers
  • "Not checked" is an allowed value
  • Send, publish, pay and delete sit outside the schedule
  • Two supervised runs are done, with the job text corrected between them
  • Someone is named as the reader of the output
  • A monthly audit is on a calendar

Common mistakes

Scheduling a topic instead of a contract. "Track competitors" produces something new every week and comparable to nothing.

Letting the run pick its own sources. You lose the audit trail and the ability to compare weeks.

No state file. The job has to invent a baseline, which is where invented changes come from.

Automating the send in week one. The one step that is expensive to undo should be the last one you automate.

Judging by the first run. A single good output tells you the model can do it once, not that the job is well specified.

Hard-coding a model name into the job. The release timeline above shows three model releases in three days; the contract should survive the next one.

What this workflow does not prove

I have not tested your sources, your tool, or any specific vendor's scheduled-task feature, and nothing here is a claim about how reliably a particular product completes work unattended. The Google statements above are Google's descriptions of its own product; the release dates are what the LLM Stats timeline displays. The design rules — the five slots, the state file, the threshold, the approval line — are a working method, not a measured result.

What you can verify is local and cheap: after two supervised runs, you will know whether your job text produces a digest you can check in ten seconds, whether the state file is trustworthy, and whether the empty case reads honestly. If any of those three fails, the schedule is not ready — and it is much easier to find that out in week one than in week twelve.