Solution · Overnight unattended runs
The agent works through the night.
Long refactors and migrations stop being painful when you're not the one staying up. Kick off the run before bed; review the PR with your morning coffee.
Updated
Some work doesn't fit in an editor session. Migrating a 200k-line codebase off React 18. Upgrading every microservice from Express 4 to Hono. Renaming a domain concept that touches every layer of the stack. The agent can do it. The question is whether you have to be awake while it works.
If the agent runs on your laptop, yes. The lid stays open, the WiFi has to hold, and you're either keeping it on your desk overnight or accepting that the run dies somewhere around 2am.
If the agent runs on Ellul, no.
The shape of an overnight run
What happens between you closing the lid and you opening it the next morning:
- Agent works on the workstation. Same Claude Code, Codex, or Cursor CLI you'd use locally. Same model, same prompts. Different home.
- State persists. Branches, scratch files, package installs, in-progress diffs; all stay where the agent left them.
- Privileged actions block on the gate. The agent doesn't push, deploy, or merge until you tap your passkey. The gate runs in a separate process that the agent cannot read or attach to.
- You sleep. Phone on the bedside. If the agent finishes early or hits a gate, you get a push notification.
A worked example: React 18 to 19 migration
Imagine a 50k-line codebase. The migration involves:
- Updating
package.jsonand lockfile across multiple workspaces. - Replacing every deprecated React API call site (3,400 of them).
- Updating every test that relies on legacy concurrent-rendering behavior.
- Running the test suite, fixing what breaks, iterating until green.
- Opening a PR that's reviewable by a human.
A senior engineer doing this manually: 2-3 days of focused work.
A Claude Code agent on a laptop: maybe 6-8 hours of agent time, plus the laptop being open the whole time.
A Claude Code agent on Ellul: same 6-8 hours, but you're asleep for most of them. You queue it at 11pm, you wake up at 7am, you read the diff over coffee, you tap your passkey to merge the PR.
What the gate does
The gate is what makes overnight runs safe. It's the answer to "what if the agent does something I didn't authorize at 3am while I'm asleep."
| Capability | Local agent | ellul | Advantage |
|---|---|---|---|
| Run the test suite | Allowed | Allowed (sandbox) | |
| Edit source files | Allowed | Allowed (sandbox) | |
| git push | Runs immediately | Pauses on passkey | |
| vercel deploy / fly deploy | Runs immediately | Pauses on passkey | |
| Talk to production database | Runs immediately | Pauses on passkey | |
| Read SSH key from agent processEllul keeps secrets out of the agent's process namespace; local agents read from ~/.ssh. | yes | no |
The agent decides what work to do. The gate enforces what the human has approved.
Setup for an overnight run
- Sign up. Pro is $50/mo (we recommend it for unattended runs because of the multi-sandbox support).
- Provision a workstation. Pre-installed with Claude Code, Codex, OpenCode, Cursor's CLI, and Grok Build.
- Bring your model key. BYOK from your Anthropic / OpenAI / Google account. Stored in the server-side vault.
- Connect a passkey. FIDO2 from your phone is the most common, since push notifications come straight to it.
- Queue the task. Either through Ellul's chat UI or by SSHing in and running the agent directly. Describe the task in detail; tighter prompts mean fewer overnight surprises.
- Walk away. The agent runs.
Morning routine
When you wake up, three states are possible:
- The agent finished. A draft PR is open. You review the diff, tap your passkey, the gate releases the merge.
- The agent is paused on a gate. It hit a
git pushor a deploy and is waiting for your approval. You either approve or reject; the agent picks up from there. - The agent stopped on an error. Persistent state on the workstation makes recovery cheap. You re-attach, see what blew up, give the agent a follow-up prompt or restart from a known-good branch.
In all three cases, the lid problem doesn't apply. The agent's progress doesn't depend on whether you closed your laptop.
When this isn't worth it
If your refactor takes 30 minutes, you don't need an overnight run. Sit at the keyboard, run the agent locally, watch it work.
If your refactor needs human judgment at every step (architecture choices, naming taste, product decisions), an unattended run will produce a PR you have to redo.
The sweet spot is mechanical-but-tedious: thousands of small, similar changes; a clear acceptance criterion (tests pass, types check, lints pass); the kind of work where the agent's per-step quality is good enough but the volume is too much for a focused session.
See also
How long can a single agent run go?
Hours. Days, in principle. Ellul workstations are persistent and don't time out at 24 hours like ephemeral sandboxes do. The actual limit is the agent's own context budget and the size of the work.
What if the agent fails halfway through?
The workstation persists. The agent's branch, its scratch files, its context: all of it stays. You can re-attach in the morning, see what happened, and either resume or restart.
Will it cost me a fortune in API tokens?
BYOK: you bring your own Anthropic / OpenAI / Google key. Your token budget is yours. Ellul charges only for the workstation ($20/mo Hobby, $50/mo Pro).
Can the agent open the PR and merge it?
Yes for opening the PR. Merging (and any other privileged action) pauses on the passkey gate. The agent literally cannot merge until you tap. That's the point of the gate.
How is this different from running it in CI?
CI is for tasks you can fully specify. Refactors with thousands of small judgment calls don't fit that shape. The agent does the judging; the gate enforces the boundaries.