# What are your agents doing all night?

> People say their agents run 24/7. Here is what they run at night, what the skeptics answer, which jobs deserve a schedule, and how I check my own scheduled agents.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2026-11-15 | Topics: [AI](https://flaviocopes.com/tags/ai/) | Canonical: https://flaviocopes.com/agents-all-night/

On November 10, Val Sopi [asked a question on X](https://x.com/valsopi/status/2120061190147801442) that got more than 300,000 views. Everyone says they have agents running all night. What are the things that need doing constantly?

The next day Ruben Gamez [quoted it](https://x.com/earthlingworks/status/2120393364600418509) with a harder version. He sees many people running agents 24/7 and burning tokens with nothing of substance to show for it, where substance means "things that significantly impact growth in their business".

![Ruben Gamez's post on X quoting Val Sopi's question about agents running all night](https://flaviocopes.com/images/agents-all-night/x-posts.webp)

I run scheduled agents on this site every day, so the question is aimed at people like me. Val's post got more than a hundred replies. This is what they say, how a few teams run their nights, and what my own agents shipped last week.

## What people say their agents do at night

Skip the jokes and the answers fall into a few groups.

| What people run at night | Examples from the replies | Does it need a model? |
| --- | --- | --- |
| Known checks | Security audits, pentesting, QA test suites, batch jobs, scrapers | No. A script or CI runs them, and an agent helps only when one fails |
| Reports and triage | Metrics reports, morning reports, inbox filtering, log analysis | Yes, once a day |
| Monitoring and research | SEO and AEO audits, analytics dashboards, scraping socials, news in one field | Yes, when a run ends in a change |
| Bookkeeping | Keeping QuickBooks clean, an invoicing pipeline for corporate customers | Partly. The rules are known, the exceptions aren't |
| Housekeeping | Large downloads of local models, cleaning up cruft | No. That's cron |
| Long data jobs | Tagging people across a huge corpus, building a knowledge graph, training runs | Yes, and the job has a natural end |
| Agents maintaining agents | Updating their own rules, skills, playbooks and work logs, self-improvement loops | It needs a model, but the only reader is another agent |
| Overnight coding | Features, bug fixes, game assets, client work | Sometimes, and you pay for it in the morning review |

### Checks, reports and bookkeeping

Brian Casel's list was SEO, audits, metrics reports, research and inbox filtering. Jenna Brinning runs a nightly security audit, has her agents update their shared rules and work logs, downloads local models, and gets her morning reports prepared. She also said she rarely gives them coding work overnight, because she's still hands-on with building.

One person has a Mac mini with more than 50 scheduled tasks a week, almost all of them between midnight and 4am, mostly accounting, security and SEO. Another has agents scan the analytics dashboards for holes and errors, pick small tasks from the backlog that don't need a decision, and look for news in their field, like new exploits.

This is the biggest group, and it's the least exciting one. It's the work a small company used to give to a part-time bookkeeper and a sysadmin.

### Building while you sleep

Some people do hand code to the night shift. There's a developer who has agents build the features he thought of during the day, and a game developer who wakes up to new assets and features to test. Someone else says a large enough feature takes days or weeks even with half a dozen agents in parallel, and that the last one he handed off broke down into more than 150 tickets.

The most honest answer came from someone who starts a team of agents around 23:00 when he has a backlog, and reads the sprint report at 8:00. He doesn't do it every night, because he can't afford it.

### Long jobs with an end

A few answers are neither a schedule nor a coding project. They are one big job that takes many hours.

Someone has agents reading through the 24 dynastic histories of China and tagging every mention of a person. Someone else is parsing GitHub into a knowledge graph. There's neural network training, model distillation, and reverse engineering.

Two small ones I liked. An agent goes through screen recordings of a family organizer app and produces demo videos with voice-over, ready for review in the morning. Another fixes clipping and collision problems in hand-made animations, in bulk.

These run at night because they're slow, and they stop when the corpus is finished.

## The other half of the thread

A large part of the replies didn't answer the question, and asked their own instead.

The most common one is about money: how much it costs, and how people pay for it. Nobody who listed their overnight jobs gave a number.

Then the hour. One reply pointed out that the models are fast now, so most of this can wait until the morning and run while you have coffee.

Several people said they can't get an agent to run unsupervised for long. Context compaction breaks long runs. The agent stops to ask permission unless you give it full access. It goes off the rails, or it stops on a decision it could have made alone.

One reply asked whether people who get thousands of new lines every morning really understand them, and what happens if they don't read them at all.

Then the motives. One person said that with a $200 subscription you feel you have to get your money's worth, so you end up running something, anything. Another called it a flex, like people who post about their income while selling a course. Several used the words productivity theater, and one asked why nobody shows what they achieved if it works so well.

Some of the jokes say the same thing. One person's agents spend the night checking on the other agents. Another's are building more agents. A third has one that runs all night looking for agent use cases, and it's still looking.

There was also a fair question from someone in B2B account management. If your job is talking to clients who work during the day, what would you even run at night?

One reply said the night's job is fixing the code that broke during the previous night's run. It's a joke, and it's also the cost of the last row in the table.

## Two different things called "all night"

One reply asked whether these agents work for six hours without stopping, or whether it's a scheduled thing, because the two are very different. Under Ruben's post, another reply said people mix up a few cron jobs scheduled at night with a factory whose only limit is tokens per second, and that the second one is rare.

Val himself answered that he has a few things that do daily checks, once, and nothing that runs all night.

| | A scheduled job | A long run |
| --- | --- | --- |
| How long it works | Minutes | Hours |
| How often | Every day or week | When there's a big enough task |
| What starts it | A clock or an event | You, at the end of the day |
| What it leaves | One small commit, a report, a PR | A big branch, or a log of experiments |
| What checks it | You, in a minute or two | Tests, a metric, then you for an hour |
| Where it goes wrong | It runs forever and nobody reads it | The morning review is bigger than the morning |

Most of the replies describe the left column. The posts that go viral describe the right one.

### Long runs that work have a judge

The cleanest example of a long run is Andrej Karpathy's [autoresearch](https://github.com/karpathy/autoresearch). An agent edits a training script, trains a small model for exactly five minutes, and keeps the change if the validation score improved. That's about 12 experiments an hour and about 100 in a night, on one GPU.

It works unattended because a number decides, and nobody has to read 100 diffs in the morning. The long data jobs from the thread are similar: the corpus is the boundary, and you can spot-check the tags.

Coding is harder because "better" isn't one number. The [Ralph loop](https://ghuntley.com/ralph/), which Geoffrey Huntley described in July 2025, is a shell loop that feeds the same prompt file to a coding agent again and again. He's clear about its limits. He says it's for starting new projects, that you should expect to get about 90% of the way, and that he wouldn't use it on an existing codebase.

Conveo's engineering team wrote up [Nightwatch](https://engineering.conveo.ai/posts/nightwatch), their own night shift. They plan in the afternoon and turn the plan into a spec and tickets. A remote orchestrator then runs 3 to 10 workers, each on one ticket in its own worktree, and merges their work into one PR. One feature took 7.5 hours on 3 agents. They only use it for multi-day features, because the setup isn't worth it for a bug fix, and they say the first version they find in the morning usually needs rework.

Thoughtworks put "unattended overnight agentic builds" in the Trial ring of its [Technology Radar](https://www.thoughtworks.com/radar/techniques/unattended-overnight-agentic-builds) this month. The entry comes with conditions: a sandbox, work specified up front, a way for the agent to see its own errors, and a test harness the team trusts. It also warns that a night of output can be too large to review line by line.

I tried the long run once, with Codex Goal mode and the instruction "recreate PocketBase". It ran for over 24 hours and produced two impressive prototypes that both needed a lot of manual work. I wrote about it in [things I let coding agents do unattended](https://flaviocopes.com/agents-unattended/#15-run-a-fleet-of-agents-with-no-end). It had no judge except me, and I was asleep.

### Scheduled jobs that work have a record

On the scheduled side, a good public example is the team behind AgentsRoom, who [run seven agents every evening](https://agentsroom.dev/blog/seven-scheduled-ai-agents-beyond-coding) on a Mac mini. Six start at 20:00: one reads the dashboards and the error logs, one fixes bugs from the queue, one handles SEO, one proposes product ideas, one writes social posts, one updates the docs. At 22:00 a seventh reads their reports and sends one short email.

They published numbers after 33 nights: 31 morning emails, 51 bugs fixed with a commit link each, and 7 blog articles in 20 languages. That answers the reply asking why nobody shows results. The agents coordinate through report files committed to the repository, and each run starts from the last commit the previous run saw.

Anthropic's [own examples](https://claude.com/blog/introducing-routines-in-claude-code) for Claude Code's [cloud scheduled tasks](https://code.claude.com/docs/en/routines), which were called routines at launch, are modest too: triage the new issues every night, and check once a week for docs that drifted from the code.

## Work that needs to run while you sleep

A job earns a schedule when something changes without me. A provider changes a price, a post goes stale, something gets published and the changelog needs an entry.

This is one day of scheduled agents on this site, from the Git history:

```bash
git log --reverse --since='2026-11-14 00:00' --until='2026-11-14 23:59' \
  --date=format:'%H:%M' --pretty='%ad  %s' |
  grep -E 'deepen|internal links|glossary|changelog: record'
```

```text
07:04  content: deepen 4 thin posts (react-conditional-rendering, linux-command-df, javascript-return-values, sqlite-user-permissions)
08:03  content: internal links for 2026-11-14
09:32  content: add LLM and generative AI glossary entries
21:01  changelog: record November 14 guides and prompt audit
```

The day starts at 7:00, when an agent picks four thin old posts and expands them. An hour later another one adds internal links between pages, and around 9:30 two new entries land in the [AI glossary](https://flaviocopes.com/ai-glossary/). The [changelog](https://flaviocopes.com/changelog/) gets the day's entry at 21:00, from a [Grok Bot](https://flaviocopes.com/grok-bot/) routine that hands the edit to a Cursor cloud agent.

There's one more that runs every two weeks. A Grok Bot checks the provider prices behind HostingPicker and Payment Processor, and a cloud agent opens a PR that [I read and merge by hand](https://flaviocopes.com/agents-unattended/).

None of them runs all night. Each one starts, commits and stops, and for the rest of the day nothing is running. I call them scheduled agents, but most of them are a cron job with a model inside.

## Why at night?

The reply that asked why this can't wait for the morning deserves an answer, because most of the time it can. My own jobs run at 7:00, 8:00, 9:30 and 21:00. The hour doesn't matter. They only have to be done before I'd need the result.

There are a few good reasons to pick the night. Jenna's is that she doesn't want those jobs running on her machine while she's working on it. Big downloads and training runs take hours whenever you start them, so you start them when you leave. A morning report has to exist by the morning.

The weak reason is the subscription. A plan with a weekly limit feels wasted while you sleep, so you find something for it to do. That's how you end up with the list from the skeptics. I priced a month of my own usage in [API pricing vs subscription](https://flaviocopes.com/ai-subscription-vs-api-pricing/), and a plan pays for itself with normal daytime work. It doesn't need a night shift to be worth the money.

## Grok Bot and OpenBot made the schedule cheap

Putting an agent on a clock used to mean a server and a [crontab](https://flaviocopes.com/cron/). Now it's a sentence in a chat.

In Grok Bot, a [routine](https://docs.x.ai/grok-bot/skills-routines-and-automations) starts a Bot on a schedule, or when a Slack message, a GitHub event, an email or a webhook call arrives. It runs on a computer in xAI's cloud, so your laptop can stay closed. I covered the setup in [the Grok Bot deep dive](https://flaviocopes.com/grok-bot/#put-the-skill-on-a-routine).

People use it for watching more than for building. Alex Finn [described](https://x.com/AlexFinn/status/2088666462819082645) a Bot that checks AI company accounts every 15 minutes. Matt Palmer [had Bots check every hour](https://x.com/mattyp/status/2116516547007308125) for cancellations at a bathhouse and a sushi place that are usually booked a month ahead, and they found him two Saturday slots. The Bot pinged him and he made the booking himself, which is how I'd set up any watch.

[OpenBot](https://github.com/CopilotKit/openbot) is CopilotKit's open source take on the same idea. You host it yourself, with a desktop app, Docker or Kubernetes, and it has routines too. I use Grok Bot and I haven't run OpenBot, so its column comes from the README.

| | Grok Bot | OpenBot |
| --- | --- | --- |
| Who hosts it | xAI | You |
| Source | Closed | Open, MIT license |
| How you create a routine | Ask the Bot in its chat | Ask the Bot in a channel |
| Shortest interval | 5 minutes | 15 minutes |
| How many routines | 50 per Bot | 20 enabled |
| What stops a runaway | 200 runs an hour per routine, 300 across all of them | A routine switches off after 10 failures in a row |

At the shortest interval, one Grok Bot routine runs 288 times a day. The docs say every run spends usage, and that includes a run that wakes up and finds nothing to do.

So the schedule is the easy part now. What takes time is reading what each run produced and deciding what to do with it.

## Work that only looks productive

One reply under Ruben's post said most of those agents write reports for the person running them. A morning report is useful when it changes what I do that morning. If I skim it and carry on as planned, I paid for tokens and got nothing back.

Agents that maintain agents are the same problem one step removed. Rules, playbooks, work logs and self-improvement loops produce files that only another agent reads. Some of that is needed. It's still overhead, and it can grow to fill any budget you give it.

Then there's polishing. A refactoring pass every night on code that already works produces a diff every morning, and somebody has to review each one.

Review is where the night shift runs out of road. Faros AI's [productivity report](https://www.faros.ai/blog/ai-productivity-paradox-report-2025), built on telemetry from more than 10,000 developers, found that teams with high AI adoption merged 98% more pull requests, and that review time on them went up 91%. Tian Pan calls the result [the morning review queue](https://tianpan.co/blog/2026-07-02-the-morning-review-queue). His advice is to size what you start at night to the review time you have the next day, and to ignore how much the agents could produce.

The workflow I use for [pull requests written by agents](https://flaviocopes.com/pull-requests-agent-review/) starts from the same limit. A PR that gets merged without being read is a [slop grenade](https://flaviocopes.com/slop-grenades/).

Another reply said many people use AI to replicate their own busywork. I think that's the fairest summary of the thread.

My own list isn't innocent here. Deepening four posts a day is a bet on search traffic, and the commits are the cost of the bet. Whether it pays shows up in Search Console weeks later.

## What the runs that work have in common

Reading the teams that publish results next to the people who say it doesn't work, the same few things come up.

- The job ran by hand first. The Grok Bot docs say to start with a one-time task, make it reliable, and only then automate it. If I keep correcting a prompt in chat, it isn't ready for a clock.
- The prompt stands alone. Nobody is there to answer a question, so the prompt says what to do, what done looks like, and what to do when blocked: stop and report.
- Something other than a person checks the work: a validation score for autoresearch, a test harness for a build, or a commit link per fixed bug for AgentsRoom.
- Risky areas stay out. Auth, payments, data models and anything that sends email don't go in an unattended run. My full list is in [things I let coding agents do unattended](https://flaviocopes.com/agents-unattended/).
- The state lives in files. Reports are committed, and the next run reads them before it starts, so it doesn't repeat yesterday's findings or skip a day.
- Every run has a stop: a failure cap like OpenBot's, a spending limit in the runner, or an orchestrator like Conveo's that checks every 15 minutes whether its workers are still committing.
- The night is sized to the morning, meaning one report, one PR, or a handful of commits. If the morning starts with reconstructing what happened, the night was too big.

Parallel workers add one more rule, which I covered in [parallel coding agents](https://flaviocopes.com/parallel-agents/): give each one files nobody else touches.

## How to tell the difference

I ask the same questions before anything goes on a schedule.

```mermaid
flowchart TD
  accTitle: Does this job deserve a schedule?
  accDescr: A job where nothing changes while you're away runs once by hand. A job with known steps is a script or a CI job. A job whose result nobody ships or decides on isn't scheduled. What's left is a scheduled agent at the lowest frequency that works.
  A[Job I want to run at night] --> B{Does something change without me?}
  B -->|No| C[Run it once, by hand]
  B -->|Yes| D{Are the steps already known?}
  D -->|Yes| E[Script or CI job]
  D -->|No| F{Does a run end in a shipped change or a decision?}
  F -->|No| G[Don't schedule it]
  F -->|Yes| H[Scheduled agent, lowest frequency that works]
```

The first question removes most of the list. If nothing changed since the last run, the agent rediscovers the same state and writes it up again.

The second one removes the test suites and the downloads. When you know the exact commands, a scheduler runs them for free and gives the same result every time. I went deeper on this in [what would make an overnight agent useful](https://flaviocopes.com/overnight-agent-work/).

The third one is Ruben's point. A run has to end in something: a commit, a PR, a price corrected, a reply sent, or a decision I make in the morning.

Then pick the lowest frequency that works. Prices on a hosting provider's page don't change every 15 minutes, so that routine runs every two weeks. Val's once-a-day check is the right default for almost everything else. The [scheduled agent tasks](https://flaviocopes.com/ai-glossary/scheduled-agent-tasks/) entry has how each tool sets this up.

A long run gets one more question: what decides that it's done, if I'm asleep? If the answer is "I'll look in the morning", I split it into smaller tasks and run them during the day.

## A simple weekly check

Once a week, write one line per scheduled job: how many times it ran, what it shipped, and which number it's supposed to move.

This is mine for the last seven days, counted with `git log`:

| Job | Runs | What it shipped | The number it should move |
| --- | --- | --- | --- |
| Deepen thin posts | 6 | 24 posts expanded | Search visits to those posts |
| Internal links | 7 | Links added in 63 files | Search visits, and how many pages a visitor reads |
| Glossary | 6 | 12 new entries | Search visits to the glossary |
| Changelog | 6 | 6 entries | None, it's a record for readers |

Runs and commits are the cheap columns to fill. The last column is the one Ruben is asking about, and for three of my four jobs the answer is a search number I can only read weeks later.

Count from the place where the work lands, not from the agent's own history. Grok Bot keeps the 20 most recent runs of each routine, and a routine that runs daily goes past that in three weeks. The Git history keeps everything.

If a job has nothing in the last column, pause it for a week. If nothing you measure gets worse, leave it paused.