# How to automate a recurring weekly report with Claude or ChatGPT

> A step-by-step guide to running an AI report on a schedule: ChatGPT scheduled tasks, Claude Cowork recurring tasks, Claude Code routines, Zapier and Make, or your own cron. Which plans get what, the hourly floor almost all of them share, where the output actually lands, and why a green run status does not mean the report was right.

Canonical page: https://www.heybeagle.com/guides/how-to-automate-a-weekly-report-with-ai

Last reviewed: 2026-07-30

The weekly report, without the weekly. Five schedulers, and the four steps that matter more.

The received wisdom that ChatGPT can schedule work and Claude cannot went out of date in 2026. Both can. Which is a good moment to point out that the scheduler was never the hard part.

## The short answer

Both vendors now ship first-party schedulers, so the 2025 advice to reach straight for cron is out of date. ChatGPT has scheduled tasks on Plus, Pro, Business and Enterprise, including monitoring tasks that only notify you when something has actually changed. Anthropic has no scheduler in plain Claude chat, but it has four elsewhere: recurring tasks in Claude Cowork on any paid plan, routines in Claude Code that run on Anthropic's infrastructure, local scheduled tasks in Claude Code Desktop, and scheduled posts in Claude Tag for Slack. Almost all of them share an hourly floor, so anything more frequent means an automation platform or your own cron. None of that is the difficult part. Setting up a schedule takes ten minutes; the project is getting the AI to the data the report needs, keeping it from doing arithmetic in its head, putting the output where the team already reads, and noticing when a run quietly stops working. Anthropic documents that last one with unusual candour: for routines, a green status means the session started and exited without an infrastructure error, not that the task in your prompt succeeded.

## At a glance

- **Is there an official way?**: Yes, on both, and this is recent. ChatGPT has scheduled tasks, expanded in June 2026 with a dedicated Scheduled page, one-off runs and monitoring tasks. Anthropic has recurring tasks in Cowork, routines in Claude Code, local scheduled tasks in Claude Code Desktop and scheduled posts in Claude Tag.
- **Plans it needs**: ChatGPT scheduled tasks run on Plus, Pro, Business and Enterprise, with a small cap on how many can be active at once - three on Go and five on Plus at the low end, up to fifteen on the top tiers. Cowork tasks need any paid Claude plan and are still rolling out, starting with Max. Claude Code routines are a research preview on Pro, Max, Team and Enterprise.
- **How often it can run**: Hourly, at best, almost everywhere. ChatGPT will not run a task more than once an hour, Cowork offers presets rather than cron, and Claude Code routines reject anything under an hour. Minute-level control means an automation platform or your own scheduler.
- **Where the output lands**: Inside the product, mostly. ChatGPT notifies in the app, by push and by email. Cowork results appear on its scheduled tasks page. Getting a report into a Slack or Teams channel usually needs a different tool from the one that ran it.
- **Time to set up**: Ten minutes for the first version. Then a week or two of the real work, which is access to the data and enough trust in the output that somebody stops checking it by hand.
- **What it costs**: Nothing extra on the vendor schedulers beyond the subscription. An automation platform bills per run in tasks, credits or activities. Your own cron bills tokens, which for a weekly report is cents per run.
- **Biggest limitation**: Silent failure. No vendor documents an automatic retry or a this-run-failed alert, and Anthropic says plainly that a green run status only means the session exited cleanly. Blocked network requests and missing tools show up in the transcript, not the dashboard.

## Side by side

Six ways to make a report happen without you. Rows four and seven are the ones people discover late: where the output lands, and whether anything tells you when a run stopped working.

| Capability | ChatGPT scheduled tasks | Cowork recurring tasks | Claude Code routines | Zapier or Make | Your own cron | Beagle |
| --- | --- | --- | --- | --- | --- | --- |
| No code to write | Yes | Yes | Partly (A prompt and a repo) | Yes | No | Yes |
| Runs with your laptop closed | Yes | Yes (Anthropic's cloud) | Yes | Yes | Yes | Yes |
| Can run more often than hourly | No (Hourly floor) | No (Presets only) | No (Hourly floor) | Yes (Minute level) | Yes | Yes |
| Delivers into Slack or Teams | No (In-app, push or email) | No (Its own task page) | Partly (Via your connector, as you) | Yes | Partly (You build it) | Yes (It lives there) |
| Reaches the systems the numbers live in | Yes (Apps you connected) | Yes (Connectors and files) | Yes (Repos and connectors) | Yes (Their catalogue) | Partly (You wire each one) | Yes (~3,200 apps) |
| Holds outbound sends for a human | Yes (Important actions gated) | Partly | No (No prompts mid-run) | No (It just fires) | No (You build it) | Yes (Every send) |
| Tells you when a run quietly failed | No (Tasks can pause silently) | No | No (Green is not success) | Yes (Auto-off, and it emails) | No (You build alerting) | Partly (Run history) |
| Nothing to pay beyond your plan | Yes (Plus and up) | Yes (Paid plans) | Yes | No (Per run, in their unit) | No (Tokens and hosting) | No (Free tier, then credits) |

## What each one actually is

Pick on two questions, not on brand: how often does it need to run, and where does the answer need to appear. Those two eliminate four of these six immediately.

| Approach | What you get | Where it stops |
| --- | --- | --- |
| ChatGPT scheduled tasks (Ten minutes. Plus and up) | Describe the job in a chat, ask for it weekly, and it appears on the Scheduled page with its next run time and pause, edit and delete controls. Tasks can browse the web and use the apps you have connected. Monitoring tasks are the underrated variant: they check for a change and stay quiet unless there is something to say. | Hourly floor, a handful of active tasks per plan, no webhooks, and the output arrives in the app, by push or by email rather than in a team channel. Tasks can pause after a period of inactivity, and deleting the chat a task belongs to pauses the task too. |
| Claude Cowork recurring tasks (Ten minutes. Any paid plan) | The closest Anthropic equivalent for non-developers. Set a task to hourly, daily, weekdays or weekly and it runs remotely on Anthropic's infrastructure, so it fires with your machine asleep. Each run is a fresh session that reads files, connectors and context at execution time. | Presets rather than cron, no local folder for a cloud-scheduled task, and results land on Cowork's own scheduled tasks page rather than being pushed anywhere. Still rolling out across plans, so check whether your tier has it before you promise it. |
| Claude Code routines (An hour. Research preview) | The most capable of Anthropic's schedulers: a saved prompt plus repositories and connectors, triggered by a schedule, an HTTP call or GitHub events, running on Anthropic-managed infrastructure. This is the one that can genuinely write its output into Slack, a pull request comment or a dashboard. | A research preview, so limits and the API surface may change. Routines belong to one person rather than the team and every action appears as that person. They run autonomously with no permission prompts, so whatever tools you include, Claude may use - writes included. |
| An automation platform (An afternoon. A separate subscription) | Zapier, Make and n8n give you real scheduling control, minute-level timing, a catalogue of destinations and, crucially, error handling that exists. Zapier turns a Zap off and emails you when it errors persistently; Make disables a scenario after consecutive failures and offers retry and resume directives per module. | You are paying per run in a unit that differs per vendor - tasks, credits, executions or agent activities - and the AI step usually multiplies it. The automation acts as the platform's own connection rather than as the person asking, and Zapier's own advice is to keep an agent to three to five related actions. |
| Your own cron and the API (Days. Then forever) | Total control of the prompt, the model, the tools and the destination, for a token cost that is genuinely trivial at weekly cadence. Prompt caching and batch pricing take it lower still if the job is repetitive. | Every platform has a documented way of failing quietly. GitHub disables scheduled workflows in a public repository after 60 days without activity, warns that scheduled events can be delayed at the top of every hour, and only runs them on the default branch. Vercel does not retry a failed cron, keeps executing a schedule whose target path now returns 404, and does not update active crons on an instant rollback. |
| An AI teammate that already lives in the channel (Minutes. Any Slack or Teams workspace) | The shape that skips the delivery problem entirely, because the thing running the job is already where the report is meant to appear. Beagle is one of these: it runs scheduled work, reads the systems the numbers live in under your own grants, posts into the channel, and holds anything outbound for approval. | You are adopting someone else's product decisions rather than writing your own pipeline. If what you need is a report assembled from a warehouse on a five-minute cadence, build that instead. |

## Step by step

Step one looks like a waste of a morning and is the highest-leverage thing in this guide. Do not skip it.

1. **Write the report by hand, once** - Before you automate anything, produce the exact report you want and keep it. It defines what success looks like, which the prompt will need to state explicitly because there is no human in the loop to clarify. It also gives you the thing to diff against when you are deciding whether to trust run three. Keep it: This becomes both the spec and the baseline
2. **Decide where it has to land before you pick a tool** - This eliminates most of the options in one move. If the report has to appear in a Slack or Teams channel, the two easiest schedulers are out: ChatGPT notifies in-app, by push or by email, and Cowork puts results on its own page. Delivery, not intelligence, is what usually forces a team onto an automation platform or their own code.
3. **Match the scheduler to your cadence floor** - Weekly or daily is comfortably within every option here. Anything under an hour rules out ChatGPT tasks, Cowork and Claude Code routines in one go, because all three enforce an hourly floor. Note also that punctuality is not promised anywhere: routines stagger by a few minutes, Zapier says only that a Zap runs within a few minutes of its scheduled time, and scheduled GitHub Actions are explicitly delayed at the top of the hour.
4. **Give it the data, and be clear whose access it is using** - This is the actual project. Connect the systems the numbers come from, and check what identity the run uses, because the answer differs sharply. Connector-based paths inherit the connecting person's permissions. A Claude Code routine acts as the individual who owns it, and every commit and message appears as them. An automation platform acts as its own connection, which is not anybody's permissions.
5. **Make it compute rather than estimate** - Do not let the model do the arithmetic. On a benchmark of financial spreadsheet questions published in 2026, the best model reached 82.4% accuracy overall and fell to 48.6% on the largest files, and the authors concluded that no standalone model is accurate enough for unsupervised use in professional finance. The fix is the one both vendors document: have it write and run code for anything numeric, so the number comes from arithmetic rather than from prediction. Rule: Model writes the query and the prose. Code produces the numbers.
6. **Keep a human on anything outbound** - A report that gets read is different from a report that gets sent. ChatGPT gates important actions such as sending an email behind an approval card by default, and the setting that removes that gate is flagged by OpenAI as elevated risk. Claude Code routines have no permission prompts during a run at all. Decide deliberately which of your runs is allowed to touch anyone outside the team.
7. **Build the failure alarm yourself, because nobody ships one** - No vendor here documents an automatic retry or a run-failed alert. Anthropic is the most honest about it: a green status on a routine means the session started and exited without an infrastructure error, and blocked network requests, missing connector tools and task-level failures show up only inside the run transcript. The cheap fix is to make the report always post something, even when it has nothing, so silence becomes a signal rather than the normal state.
8. **Diff two runs before anyone is allowed to trust it** - Run it twice on the same data and compare. Identical inputs do not produce identical outputs - Anthropic states this outright, noting results are not fully deterministic even at temperature zero - and you want to know how much the wording moves before somebody forwards it to a client. If the numbers move, go back to step five. If only the prose moves, you are fine.

## What trips people up

Everything that goes wrong after the demo works, roughly in the order it will happen to you.

- **The scheduler is ten minutes, the data access is the project** - Every guide to this topic is a guide to the ten-minute part. The month goes on the rest: which systems hold the numbers, who is allowed to see them, whether the AI is running as a person or as a service connection, and what happens to the report when someone renames a field. Plan the schedule last.
- **Green does not mean it worked** - This is the failure mode that costs the most trust, because it looks like success from the dashboard. Anthropic documents it for routines in as many words. The pattern repeats everywhere: GitHub disables scheduled workflows in public repositories after 60 days without activity, Vercel does not retry a failed cron and keeps firing a schedule whose target now returns 404, and a ChatGPT task pauses quietly after a period of inactivity or if you delete the chat it belongs to. Assume the job is dead until it proves otherwise every week.
- **The same prompt does not produce the same report** - Anthropic's own glossary states that results are not fully deterministic and identical inputs may produce different outputs across calls, even at temperature zero, on first-party and third-party infrastructure alike. One published experiment ran a single prompt a thousand times at temperature zero and got eighty distinct completions, all identical for the first 102 tokens before diverging. For a weekly report that means the wording will drift. Make sure the numbers do not.
- **Nobody is watching for the prompt injection** - An unattended run is the ideal target, because the whole defence in an interactive session is a human noticing something odd. OWASP's guidance says outright that it is unclear whether fool-proof prevention of prompt injection exists. Anthropic measured a 23.6% attack success rate against browser-using Claude without mitigations, reduced to 11.2% with them in autonomous mode - better, and not zero. If your report reads external content, assume that content can try to give it instructions.
- **Credentials expire on a schedule of their own** - The most common cause of a report that worked for two months and then stopped. Google revokes refresh tokens after seven days for apps left in testing status, and expires any refresh token unused for six months. Microsoft Entra ID deactivates refresh tokens after 90 days of inactivity and no longer lets you configure that lifetime. A per-routine API token is shown once and cannot be retrieved later. None of these announce themselves.
- **The billing unit is where the automation platforms differ** - Comparing Zapier, Make and n8n on headline price is meaningless because they meter different things: Zapier bills tasks and meters its agents separately in activities, Make bills credits per module execution, n8n bills whole workflow executions. The same five-step weekly report is five units on two of them and one on the third. Zapier's AI steps additionally multiply by model tier, so a premium run with two tool calls costs fifteen tasks rather than one.
- **Somebody has to be accountable for the output** - The failure that ends up in the press is never a technical one. In the best-documented recent case, a consultancy delivered a government report containing fabricated references, including a quote attributed to a court judgment that did not exist; the report was publicly corrected twice and the firm repaid the final contract instalment of about ninety-seven thousand Australian dollars. An automated weekly report needs a named human who reads it before anyone acts on it, and that person needs to still be doing it in month six.

A schedule is a promise that something will happen. It is not a promise that anybody read it, or that it was right.

## Or skip the build

Most of the difficulty above comes from the report being assembled somewhere other than where it is read, by something that cannot see the systems it needs. Beagle is built the other way round.

- **It already lives where the report goes** - The delivery problem disappears when the thing running the job is in the channel. No push notification to forward, no export step, no second tool bought purely to move a paragraph from one app to another.
- **It reads the systems the numbers come from** - The CRM, the tracker, the inbox and the drive, under your own OAuth grants, so the report is assembled from records rather than from what somebody remembered to paste into a prompt.
- **It notices as well as reports** - The renewal coming up, the account that has gone quiet, the thread that never got a reply. A schedule fires whether or not there is anything to say. The more useful behaviour is raising the thing nobody scheduled.
- **Nothing goes out without a nod** - Beagle drafts the report and holds anything outbound for a human. On a weekly cadence that is one approval a week, which is roughly the amount of oversight an automated report deserves.

## In your stack

Teams here usually connect: Slack, HubSpot, Linear, Drive, Notion, Gmail. Beagle connects to ~3,200 tools in total - see https://www.heybeagle.com/integrations.

## FAQ

**Can ChatGPT run a task on a schedule?**

Yes. Scheduled tasks run on Plus, Pro, Business and Enterprise across web, mobile and desktop, and were expanded in June 2026 with a dedicated Scheduled page, one-off runs and monitoring tasks that only notify you when something has changed. A task can browse the web and use apps you have connected. The constraints worth knowing before you plan around it: it will not run more than once an hour, only a few tasks can be active at a time depending on your plan, there is no webhook support, and output arrives in the app, by push or by email rather than in a team channel.

**Can Claude run a report on a schedule?**

Yes, though not from plain Claude chat, which is where people look first and conclude it cannot. Anthropic ships scheduling in four other places: recurring tasks in Claude Cowork on any paid plan, which run on Anthropic's infrastructure with hourly, daily, weekdays or weekly presets; routines in Claude Code, a research preview on Pro, Max, Team and Enterprise, triggered by a schedule, an HTTP call or GitHub events; local scheduled tasks in Claude Code Desktop, which can reach local files but only fire while the machine is on; and scheduled posts in Claude Tag for Slack on Team and Enterprise.

**How do I get the report into Slack or Teams?**

This is the question that decides your tooling, so ask it first. Neither ChatGPT scheduled tasks nor Cowork recurring tasks push into a channel: the first notifies in-app, by push or by email, the second posts results to its own scheduled tasks page. The paths that do reach a channel are a Claude Code routine writing through your connected Slack connector, which posts under your identity rather than a bot's; an automation platform with a Slack step; your own code calling the Slack API; or a product that already lives in the channel.

**Will the report be the same every week?**

The numbers should be. The wording will not be. Anthropic states directly that results are not fully deterministic and that identical inputs may produce different outputs across API calls, even at temperature zero, and this holds on its own infrastructure and on third-party clouds. One published experiment ran the same prompt a thousand times at temperature zero and got eighty distinct completions. The practical response is to stop treating the model as the source of the figures: have it write and run code for anything numeric, and let it vary only in the prose around them.

**How much does it cost to run a weekly report on the API?**

Very little, which is why cost is almost never the reason a do-it-yourself report fails. At published rates, a run consuming roughly fifty thousand input tokens and a few thousand output tokens sits in the region of a few tens of cents on a mid-tier model, plus around ten dollars per thousand searches if it uses a hosted web search tool. Fifty-two of those a year is single-digit to low double-digit dollars. Prompt caching and batch pricing reduce it further. Budget your attention for the hosting, the alerting and the credential rotation instead, because that is where the real cost sits.

**What breaks first when you automate a report?**

Access, then trust, then attention. Access breaks when a credential expires on a schedule nobody tracked - Google revokes refresh tokens after seven days for apps left in testing status and after six months unused, and Microsoft Entra ID deactivates them after 90 days of inactivity. Trust breaks the first time a number is wrong, which is why arithmetic belongs in code rather than in the model. Attention breaks quietly around month three, when the report is still arriving and nobody is reading it closely enough to notice that one of its sources stopped returning data.

## Read next

- [Weekly status reports](https://www.heybeagle.com/use-cases/weekly-status-reports): What Beagle does with this job
- [ChatGPT and your knowledge](https://www.heybeagle.com/guides/how-to-give-chatgpt-your-company-knowledge): Getting it to the data the report needs
- [Claude in Slack](https://www.heybeagle.com/guides/how-to-use-claude-in-slack): Where a report is actually read

Try Beagle free: https://www.heybeagle.com/signup (1,000 credits, no credit card).