How to Run 1,000 AI Agents Overnight From Your Phone - full course

Boris Cherny, who built Claude Code, has a confirmed daily workflow that sounds almost absurd until you understand the architecture underneath it. Phone as his primary interface, not a laptop. Five to ten active sessions running at once. Each one capable of spawning sub-agents, sometimes a few hundred at once, sometimes a few thousand overnight on deeper work. Dozens of loops running continuously in the background, some persisting server-side even when his laptop is closed.

That number, a thousand agents running unattended overnight, triggered from a phone, sounds like it requires a data center and a team of infrastructure engineers. It doesn't. It requires understanding four specific architectural pieces, none of which are individually complicated, that combine into something that looks impossible from the outside and is actually just good system design applied consistently.

This is the complete course. By the end you will understand exactly how this scale of unattended work actually functions, the specific pieces that make it safe to leave running while you sleep, and how to build your own version of it, starting small and scaling to whatever number your actual work justifies, whether that's ten agents or genuinely a thousand.

The Honest Framing Before We Start

Nobody needs literally 1,000 agents running for most real work. The number itself isn't the point. What matters is the architecture that makes running any large number of agents unattended, overnight, triggered from a phone, actually safe rather than reckless. Once you have that architecture, scaling from 10 to 100 to 1,000 is mostly a matter of how much genuinely parallelizable work you actually have, not a fundamentally different system.

This course teaches the architecture at whatever scale is honest for your actual situation. The specific number 1,000 comes from a real, confirmed workflow, and it's worth using as the aspirational ceiling, not a requirement you need to hit on day one.

The Four Pieces That Make This Possible

Before any setup steps, understand what actually has to be true for unattended overnight agent work to be trustworthy rather than dangerous.

Mobile triggering. You need a way to start, check on, and redirect work from your phone, not just view it. This is different from a notification-only mobile app. It requires a real interface for sending instructions, not just receiving status updates.

Isolated parallel execution. Each agent, or each cluster of sub-agents working on one task, needs to run in its own context, its own workspace, without stepping on what another agent is doing simultaneously. Without this, running many agents at once produces chaos, not scale.

Verification that doesn't require you present. This is the piece most people skip, and it's the single most important one for anything running while you're asleep. Every agent's output needs to be checked against something real before it's treated as done, by another agent, by a test suite, by an explicit rule, not by trusting a self-reported "completed successfully."

Hard stop conditions and cost ceilings. Anything running unattended for hours needs an absolute limit on what it can spend, in time, in money, in scope, that doesn't depend on you noticing something has gone wrong. This is the piece that turns "agents running overnight" from a genuine risk into something you can actually trust.

Every step in this course builds toward having all four of these pieces working together. Skip any one of them and the system either doesn't scale past a handful of agents, or it scales in a way that can genuinely hurt you, financially or in terms of what actually ships.

Part One: Setting Up Mobile Triggering

The mobile piece is the most recently solved part of this puzzle, and it's worth understanding what actually changed to make it possible.

Claude's Dispatch interface gives you a continuous conversation with Cowork from your phone, not a read-only status view, a full interface for assigning tasks, checking progress, and redirecting work while the actual execution happens server-side or on your desktop. Before this kind of interface existed, agentic work was fundamentally desktop-bound, you set something running before you left your computer, and you couldn't meaningfully interact with it again until you sat back down.

The practical setup: install the mobile app for whichever agentic platform you're using that supports genuine bidirectional mobile interaction, not just push notifications. Confirm you can do three things from your phone specifically: start a new task from scratch, check the detailed status of a running task, and send a redirect or correction to a task already in progress. If your current setup only supports the first two, you don't yet have the mobile triggering piece this course requires, you have a mobile dashboard, which is useful but not the same thing.

Test prompt to run from your phone the first time you set this up:
"Check the status of my current sessions. For each one, tell me what
it's working on, how far along it is, and whether it needs anything
from me right now."

If that returns a real, specific answer rather than a generic "everything's running fine," your mobile triggering is actually working the way this course needs it to.

Part Two: Isolated Parallel Execution

This is the piece that actually lets you run many agents at once without them interfering with each other, and it has two layers worth understanding separately.

Sub-agent isolation within a single session. A main agent can decompose a complex task into smaller pieces and deploy sub-agents to execute them, each working in its own context rather than all of it competing for space in one continuous conversation. This is what allows a single session to spawn hundreds of sub-agents, the kind of scale Cherny's own workflow confirms, without the whole thing collapsing into an incoherent mess, because each sub-agent's work stays cleanly separated from the others.

Git worktrees for genuinely independent tasks. For work that's independent enough to run as entirely separate sessions rather than sub-agents within one session, worktrees let multiple sessions operate on separate branches or directories simultaneously without one session's in-progress changes disrupting another's. This is the mechanical infrastructure underneath running many concurrent, independent loops, not one agent working faster, but many agents genuinely working on separate things at the same time.

The practical decision rule: if a piece of work needs to see and build on what another piece of work is doing in real time, it belongs as a sub-agent within the same session. If two pieces of work are genuinely independent of each other, start them, check on them, and finish them without needing to know what the other is doing, they belong as separate sessions in separate worktrees.

Prompt for decomposing a large task into isolated sub-agents:
"Break this task into independent pieces that can be worked on in
parallel. For each piece, define its scope clearly enough that a
sub-agent working on it doesn't need to know what the other pieces
are doing. Flag any piece that actually depends on another piece's
output, since those need to run sequentially, not in parallel."

Part Three: Verification You Can Trust While Asleep

This is the piece that determines whether running agents overnight is a genuine productivity unlock or a genuine liability, and it deserves the most careful attention of anything in this course.

The core principle, confirmed directly from Anthropic's own harness engineering work: never let an agent grade its own work. A model reviewing its own output in the same context that produced it tends to skew positive, even when a human reviewer would immediately spot the flaw. This matters more for overnight, unattended work than for anything you're watching in real time, because there's no human in the loop to catch a confidently wrong "this is done" report until morning.

The practical architecture: separate the role that produces work from the role that verifies it. A Builder agent does the actual task. A separate Judge, ideally with access to something the Builder didn't have, the actual test suite output, the original requirements document, real execution results, checks the work against real evidence, not just re-reading the same output and forming a fresh opinion.

Verification prompt template for any overnight task:
"Before reporting this task complete, verify your work against
[the actual test suite / the original requirements document /
the specific success criteria below]. Do not report success based
on your own assessment of the output. Cite the specific evidence
that confirms each requirement was actually met. If you cannot
verify something, say so explicitly rather than assuming it worked."

For anything genuinely high-stakes running overnight, add a second, independent verification pass, a fresh session or sub-agent, with no memory of how the work was produced, checking the final output against the original goal from scratch. This catches the specific failure mode where a Builder and its own immediate self-check share the same blind spot.

Part Four: Stop Conditions And Cost Ceilings

The final piece, and the one most commonly skipped by people excited to get agents running overnight for the first time.

Every task running unattended needs three explicit limits, written as hard rules, not soft suggestions the agent can reason its way past.

A maximum time or iteration limit, after which the task stops and reports its current state rather than continuing indefinitely.

A maximum cost ceiling, calculated in advance based on the worst-case token usage across however many agents you're running, that the system genuinely cannot exceed regardless of how close it feels to finishing.

An explicit scope boundary, specific actions the system is never allowed to take without waking you up first, deploying to production, deleting data, spending real money outside a pre-approved budget, sending external communications on your behalf.

Stop condition template to include in every overnight task's setup:
"Maximum runtime: [X hours]. Maximum cost: [$Y]. If either limit is
reached before the task completes, stop immediately, do not attempt
to finish 'just one more step,' and prepare a summary of what was
completed and what remains for my review in the morning.
Never take these actions without my explicit approval first:
[list your specific hard boundaries here]."

Calculate your worst-case cost before your first real overnight run, not after. Multiply your expected number of parallel agents by the maximum cost each one could plausibly consume at your configured time limit. If that total number would alarm you appearing on a real invoice, your limits aren't tight enough yet, tighten them before you go to sleep, not after you wake up to the bill.

Putting It Together: Your First Real Overnight Run

With all four pieces in place, here's how an actual overnight session comes together, scaled to a realistic starting point rather than jumping straight to a thousand agents on day one.

Before bed, from your phone or desktop, define a batch of genuinely independent tasks, the kind that don't depend on each other's output. Start with somewhere between five and twenty, not a thousand, your first real test of this system should be small enough that reviewing every single result in the morning is realistic, so you can actually verify the system worked as intended before trusting it with real scale.

For each task, apply the verification template from Part Three and the stop condition template from Part Four explicitly, not as an assumption that "it'll probably be fine." Launch the batch, either as sub-agents within a coordinating session or as separate sessions across worktrees, depending on whether the tasks need to see each other's progress.

Go to sleep. In the morning, check from your phone using Dispatch or your platform's equivalent mobile interface. Review not just whether tasks report success, but whether the verification evidence attached to each one actually holds up under your own quick review. This morning review is not optional for your first several runs, it's how you confirm your verification layer is actually catching what it's supposed to catch, rather than trusting it blindly before you've earned that trust.

Scaling From Twenty To Two Hundred To A Thousand

Once your first several small batches have run cleanly, verification catching real issues when they occur, stop conditions actually firing when tested, cost staying within your calculated ceiling, scaling up is mostly a matter of confidence and genuinely available parallel work, not a different architecture.

The scaling discipline that actually matters: increase the number of parallel agents only when you have a specific, real batch of genuinely independent work that justifies it, not as a demonstration of scale for its own sake. Cherny's own thousands-overnight number happens specifically on deeper research or exploration work, where genuinely many independent paths are worth trying in parallel, not as a default applied to every night regardless of what actually needs doing.

Track your escalation-rate and cost-ceiling-trigger rate as you scale, the same diagnostic signal recommended for any loop-based system generally. If a growing share of your parallel agents are hitting their stop conditions without completing, that's telling you your task scoping or your limits need adjustment before you add more parallel agents on top of a pattern that's already struggling.

A Worked Example At Moderate Scale

To make this concrete without jumping straight to the thousand-agent extreme, here's what a genuinely useful hundred-agent overnight run looks like in practice, a realistic middle point most people building this system will actually reach before considering whether they need more.

You're researching a broad question with many genuinely independent sub-questions, evaluating a hundred potential business partners against a specific set of criteria, for instance. Each partner's evaluation is fully independent of every other partner's, no shared state, no sequencing dependency. This is exactly the shape of task that benefits from wide parallelism.

Before bed, you define the evaluation criteria explicitly, the verification standard from Part Three, and the per-agent cost ceiling from Part Four, once, as a template all hundred agents will follow identically. You launch a hundred sessions, one per partner, each isolated in its own context, each carrying the same verification and stop-condition instructions.

Overnight, each agent researches its assigned partner, evaluates against the criteria, verifies its own findings against real, cited sources rather than assumption, and reports either a completed evaluation or an explicit "insufficient information, human review needed" flag, never a confident guess dressed up as a finding.

In the morning, from your phone, you review a hundred structured evaluations instead of manually researching a hundred partners yourself over what would have been days of work. The evaluations that flagged themselves as uncertain get your direct attention first. The ones with strong, well-cited findings get a quick confirmation pass rather than a full re-review.

This is the realistic version of the thousand-agent headline. Not a thousand agents doing a thousand different types of things chaotically. A large number of agents doing the same well-defined, well-verified task across a large number of independent instances, which is exactly the shape of work that scales cleanly with this architecture.

Common Mistakes That Undermine This At Scale

A handful of specific mistakes show up repeatedly as people try to scale this system, worth knowing in advance.

Scaling the number of parallel agents before verification has actually been tested and trusted. Running a hundred agents overnight before you've confirmed your verification layer actually catches real problems in a batch of five is scaling on hope, not on evidence.

Treating stop conditions as a formality rather than testing them directly. Before trusting any batch size, deliberately give one test agent a task designed to fail its stop condition, and confirm the system actually halts cleanly rather than continuing anyway. If it doesn't stop when it's supposed to at small scale, it won't at large scale either.

Running genuinely dependent tasks in parallel because the count looks more impressive. Tasks that actually need to see each other's output, run sequentially or with explicit coordination between them, forced into pure parallel execution, produce inconsistent, hard-to-debug results. Parallelism only helps genuinely independent work.

Skipping the morning review once things have been running smoothly for a while. Complacency is the actual risk once a system has run cleanly for a few weeks. The overnight review habit is what catches drift, a verification standard that's quietly gotten looser, a cost ceiling that's crept up, before it becomes a real problem rather than after.

Troubleshooting The Problems That Actually Come Up

A handful of specific problems account for most of the friction people report when first building a system at this scale, worth knowing the fix for in advance rather than discovering them at 2am.

Agents report success but the actual output is wrong. This is almost always a verification gap, not a capability problem with the underlying model. Check whether your Judge or verification pass genuinely has independent access to ground truth, the actual test results, the actual source documents, or whether it's just re-reading the Builder's own summary and rubber-stamping it. A verification step with no independent evidence to check against will pass confidently wrong work every time, regardless of how sophisticated the prompt sounds.

Mobile check-ins show vague status instead of specific progress. This usually means your task setup didn't request structured progress reporting upfront. Add an explicit instruction for each agent to report progress in a consistent, parseable format, current step, percentage estimate if applicable, any blockers encountered, rather than leaving the format to chance. A mobile check-in is only as useful as the structure of what it's summarizing.

Cost runs higher than your calculated ceiling despite stop conditions being in place. Check whether your stop condition is actually being enforced as hard logic the Manager checks mechanically, versus a soft instruction inside the prompt that the model can reason its way past under pressure to finish. "Stop when you hit the limit" as a sentence in a prompt is not the same as a hard, code-level check that halts execution regardless of how close the task feels to completion.

Parallel agents produce inconsistent results for what should be identical evaluation criteria. This points to your template instructions genuinely varying between agents, even subtly, rather than being copied identically across the batch. Any variation in how the verification standard or success criteria are worded between parallel agents will produce variation in their outputs, since you're effectively running slightly different evaluations and expecting consistent results.

The system worked fine at ten agents and broke down at a hundred. This is usually a genuine dependency you missed when scoping the tasks as independent. Go back and check whether any of the tasks that failed at the larger scale actually needed information or context from another task running in the same batch. Parallelism failures at scale are very often sequencing problems that simply didn't surface when there were too few tasks running simultaneously for the conflict to actually occur.

The Real Cost Economics Of Running At Scale

Before scaling meaningfully past a small test batch, it's worth understanding the actual cost structure so you're making a deliberate choice rather than discovering the number after the fact.

Cost per agent scales with the model you choose for that specific task, not uniformly across your whole batch. This is where the routing discipline from earlier in this course pays off directly at scale. Running a hundred agents on your most expensive, most capable model by default, when many of those hundred tasks are actually routine enough for a cheaper model, is the single most common way an overnight batch costs far more than it needed to. Reserve your most capable model specifically for the sub-agents or tasks within the batch that are genuinely difficult, and route the routine, well-specified portions to a faster, cheaper model that performs just as reliably on straightforward, clearly defined work.

Calculate a realistic per-agent cost range before committing to a batch size, not an optimistic best case. Run a small test batch first, five to ten agents, at your actual intended settings, and use the real cost per agent from that test to project your full batch cost, rather than estimating from documentation alone. Real usage patterns, how many tool calls a task actually needs, how much back and forth verification actually requires, consistently differ from theoretical estimates in ways that matter once you're multiplying by a hundred or a thousand.

Build in a cost buffer for the tasks that hit their stop condition without completing. A task that runs to its full time or iteration limit without finishing still consumed real cost getting there, and a batch where a meaningful share of tasks hit their limits unfinished costs more per completed task than your simple per-task estimate would suggest. If you're seeing a high rate of incomplete, limit-hit tasks in your test batches, that's a signal to either loosen the specific limit slightly or tighten the task scope, not just to accept the inefficiency as a cost of scale.

What This Actually Buys You

The genuine value of this system isn't the impressive-sounding number. It's the specific hours it returns to you. Research that used to take days of manual work compressed into an overnight run you review in twenty minutes over coffee. A backlog of independent, well-defined tasks that used to compete for your daytime attention, handled while you were asleep, verified, and waiting for a quick review rather than a full redo.

Cherny's own framing is worth returning to here: "we're only 1% done." The specific architecture in this course, mobile triggering, isolated parallel execution, real verification, hard stop conditions, is not a fixed, final system. It's the current state of a practice that keeps evolving as the tools underneath it get more capable. Build the four pieces properly at whatever scale is honest for your actual work today, and scaling further, when you genuinely have the parallel work to justify it, becomes a matter of confidence in a system you've already tested, not a leap into the unknown.

Follow @cyrilXBT for the exact templates and setups behind everything in this course.

Join my tg family here t.me/+CuGQgufhkk0xY…