Run your company
on your own machine
Nightshift is a local agent fleet that ships features, writes content, researches competitors, drafts outreach and reports on revenue, on a schedule, continuously. It drives the Claude Code or Codex CLI you already pay for, and it never accepts work until a real command proves it.
What people actually run it for
Every one of these is a role on a schedule, and every one has to prove its work with a command before it counts as done.
Ship features continuously
It picks the highest-value task, implements it, writes tests for what it changed, and stops when the gates pass. Every cycle, without being asked.
Proven by
npm test && npm run lintBackfill missing tests
Point it at the untested parts of a codebase and let it grind through coverage a little on every cycle, instead of never.
Proven by
go test ./... -coverRun a content engine
A post, a landing page rewrite or a changelog entry every few hours, saved as files for you to review. Nothing publishes itself.
Proven by
word count and no placeholder textWatch competitors and the market
Findings appended with the date and sources, noting what changed since last time rather than repeating itself.
Proven by
today's date appears in the research logDraft outreach that never repeats itself
Prospects found and messages drafted one per person. Policy forbids contacting anyone twice, and drafts wait in the outbox.
Proven by
drafts landed in the outboxTriage the support inbox
Reads unanswered messages and drafts a reply to each, flagging refunds, legal matters and angry customers for a human.
Proven by
a draft exists for every open threadReport on revenue without touching billing
Reads subscription and revenue data through your own payments connector and writes a short report. Read-only, always.
Proven by
a report was written todayGrind through upgrades and migrations
Dependency bumps, framework migrations and long refactors are ideal unattended work: repetitive, verifiable and easy to revert.
Proven by
the build and full suite still passHave one model review another
Pin a reviewer role to Codex inside a Claude fleet. Genuine cross-model adversarial review, in the same run.
Proven by
review notes written, findings triagedKeep docs and changelogs honest
Documentation drifts because nobody owns it. A scheduled role that reads the diff and updates the docs does.
Proven by
docs mention every new public functionThe last five need a connector you already have: email, inbox, social, ads or payments. Without one, that role skips and says so rather than pretending it worked.
Everything Nightshift does
All 64 features, grouped by the problem each one solves. Most of them exist because unattended work fails in boring, predictable ways.
The fleet
Specialised roles, not one agent doing everything.
- Ten roles covering building, testing, planning, content, research, social, outreach, support, ads and revenue
- Each role gets its own standing instruction, schedule, model and permissions
- Roles declare a capability (email, inbox, ads) rather than a vendor, so a fleet is portable
- Claude Code and Codex can be mixed in one fleet, so one model reviews another's work
- Per-role model choice, so cheap work does not use an expensive model
- Roles are enabled, disabled and edited by hand in a single readable file
- A generated fleet is a starting point you are expected to change
Verification
Nothing is accepted because the agent said so.
- Every role can require gates: real shell commands that must pass
- Gates fit the work: test suites for code, word counts for articles, dated entries for research
- Custom expected exit codes, so "there must be no TODOs" is expressible
- Required output matching, so a command that exits zero without doing the job still fails
- Per-gate timeouts; a gate that cannot finish proves nothing and fails
- Gates stop at the first failure instead of burning time on the rest
- The gates are shown to the agent, so it self-checks before finishing
- A failed gate feeds its real command and output back into a bounded repair attempt
- Repair attempts are capped, so a permanently broken gate cannot loop all night
- The agent is told not to weaken, skip or disable a check to make it pass
Autonomy
It keeps working, and remembers what happened.
- Cron cadences per role, deliberately staggered so two roles never collide
- Continuous serve mode, or a single pass with one command
- Catch-up after downtime, coalesced into one run per role by default
- A month offline never queues hundreds of runs
- A restart never re-runs a window that already completed
- Session continuity per role, so each cycle remembers the one before it
- Recent history written into CLAUDE.md and AGENTS.md, bounded and inside markers
- A durable run log of every attempt, gate result and outcome
- Status output showing what each role last did, why, and what is next
- Clean shutdown on Ctrl-C, terminating the agent and everything it spawned
Safety
Designed for something running unattended with shell access.
- Three sandbox levels, defaulting to workspace and never wider
- Unrestricted access requires a separate top-level opt-in, so it cannot hide in one role
- Unrestricted access is refused on Codex, which has no per-task tool allowlist
- Read-only roles are forced into a read-only sandbox whatever their prompt asks
- Draft mode by default for anything outbound: files for review, nothing sent
- Publishing is opt-in per role, never a default and never generated
- A policy of forbidden and review-required actions, injected into the agent's own instructions
- Per-task tool allowlists on Claude, with the gap reported honestly on Codex
- Secret scanning on the staged diff refuses commits containing credential shapes
- A daily token ceiling that stops the fleet instead of failing halfway through
- Wall-clock limits per cycle, so one wedged role cannot consume the night
- Retries only for failures that could plausibly succeed; exhausted turns are never retried
Isolation
Parallel work that cannot overwrite itself.
- Each writing role works in its own git worktree on its own branch
- Gates run inside that checkout, so they verify the isolated copy
- Verified work merges back through a queue that serialises merges
- A merge conflict aborts, preserves the branch and names the conflicting files
- Conflicts are never auto-resolved, because guessing at 3am destroys work
- Work that fails verification never reaches your base branch
- Configurable concurrency, falling back to sequential without a git repository
- Checkouts left behind by an interrupted run are cleaned up on the next cycle
Local and private
There is nothing to send anywhere.
- A single compiled binary with no runtime dependencies
- No network calls to BigIdeasDB, ever, once downloaded
- Runs on the Claude or Codex subscription you already pay for
- No revenue share, no per-task credits, no metered tasks
- Your repository, your branches, your hosting, your accounts
- Existing MCP configuration is read, never written or modified
- Only roles that declared a connector are handed one
- Builds for macOS (Apple silicon and Intel), Linux (x86_64 and arm64) and Windows
- Published checksums so you can verify what you downloaded
- Run state is git-ignored and holds no credentials
Operating it
Boring, inspectable tooling.
- A preflight check for CLIs, versions, git state and connectors
- Validation that shows the whole schedule and the next fire time per role
- A dry run that shows exactly what would happen and runs nothing
- Unknown keys in the config are a loud error, not a role that silently never runs
- Per-provider capability reporting, so you know what a provider will not honour
- One role runnable on demand, regardless of its schedule
- Legacy prompt CSVs importable into a fleet
The same idea, the opposite ownership
Hosted platforms that run a company for you got the operating model right. What they got wrong is who ends up holding the business.
| Hosted AI platform | Nightshift | |
|---|---|---|
| Where it runs | Their servers | Your machine |
| Where your code lives | Their GitHub organisation | Your repo, your branches |
| Your accounts | Their integrations | Your own connectors |
| What it costs | Subscription, plus a share of revenue, plus per-task credits | The Claude or Codex plan you already have |
| When the platform breaks | You wait for support | You read the files and kill the process |
| Getting your work out | An export feature, if it works | It was never anywhere else |
| Proof the work is done | The agent reports it finished | A command has to agree |
| Running 24/7 | Yes, on their infrastructure | ~When your machine is awake, or on any box you own |
The honest tradeoff: a hosted platform runs around the clock and a laptop that sleeps does not. Nightshift catches up on the windows it missed when you wake it, and if you want genuine always-on you can run it on a small VPS or any machine you leave on. That is the one row where hosting wins, and we would rather say so than pretend otherwise.
Three commands, then it runs itself
No dashboard to babysit, no agent sandbox to sync, nothing uploaded.
Describe what you want
One command spends a single agent call designing the fleet: which roles you need, what each one does, when it runs, and the command that proves its work.
nightshift init "grow this SaaS to 50 paying customers"
Read it, then change it
The whole system lands in one readable file. Every role, cadence, gate, limit and policy rule is there in plain text, and you are expected to edit it before running anything.
nightshift validate # shows the full schedule $EDITOR nightshift.yaml # it is yours
Let it work
Roles fire on their cadences. Each one is verified, retried when a retry could help, and logged. Progress lands in your memory files so tomorrow's run knows what happened today.
nightshift serve --concurrency 2
Put the day to day on autopilot
Shipping features, writing content, watching competitors, drafting outreach, answering support and reporting on revenue. Running on a schedule for as long as you leave it on, with you approving anything that reaches a customer.
Frequently Asked Questions
Everything you need to know about Nightshift.