stop building the daemon. build the door.
everyone wants the agent that never sleeps. the one that grinds through your backlog at 3am and hands you a finished world by breakfast.
that agent exists. it's called a server. and you don't need another one.
the real move is the opposite. the agent that tells you to stop. the one that closes the laptop on your behalf, captures what you actually did, runs the low-risk work while you dream, and hands you a morning brief that takes minutes, not hours, to process.
this isn't a vibe. this is the structural answer to how autonomous work actually survives contact with a human life. and the research is clear: the product isn't another overnight daemon. it's the handoff layer between your day and your sleep.
two products fused, nobody owns the fusion
look at what's out there and you'll see the market split in half.
on one side, the bedtime crew. go-to-damn-bed escalates from gentle reminder to outright refusal, then writes tomorrow.md with your next three concrete steps before it lets you leave. agent-bedtime injects bedtime context through a hook. sleepops treats sleep as an invariant and removes decisions for adhd transitions. agent wellbeing kit sends advisory quiet-hour nudges.
on the other side, the overnight workers. sleepless agent runs tasks as a daemon. junior runs claude code in isolated worktrees. munder difflin uses a stop-hook queue loop. cass works a fixed 00:30 to 06:00 window.
and then the morning people. dunnit reschedules and queues yes/no decisions while you sleep. poha produces a phone brief before your alarm. aitne drafts a one-page day plan at 04:00.
three clusters. three separate behaviors. and no one has fused them into one product that says: stop, capture, run, review.
the closest attempts are local prototypes with one star and n=1 evidence. that's the gap. that's the opening.
controller not agent is the only architecture that survives
here's the uncomfortable truth about long-running agents: they rot.
context degrades. security surface widens. a perpetual session that holds a multi-day project in its own memory is a liability, not a feature.
the implementations that actually survive unattended work all converge on the same shape. the model sleeps. the controller doesn't.
vitatii elenhaupt's autonomous agents that sleep work makes this explicit: a durable external controller holds state and wakes short-lived agent turns only when the world changes. tomasz tunguz recommends a 24-hour coordinator with ephemeral specialists and a midnight reset. munder difflin's loop uses claude code's stop hook and a work queue to decide when the agent keeps going. loco-agent is an async-first scheduler. ans is a governance layer that only permits proceed, park, or halt, never ask.
this is not a vibe. it is the structural answer to long-horizon fragility. the model holds one bounded turn. the controller holds durable state. the agent is the hand. the controller is the brain that doesn't sleep.
the handoff artifact is the moat, not the agent loop
here's what most builders get wrong. they obsess over the agent. the loop. the intelligence.
the value lives somewhere else entirely. in the artifact the agent leaves behind.
claude code's own docs are explicit: scheduled tasks run autonomously and cannot ask clarifying questions. so the prompt must define success criteria and result handling in advance. local skills aren't automatically available to cloud routines, which start as fresh remote sessions.
meaning: the product isn't the agent. the product is the boundary object it leaves for the human.
look at the systems that feel trustworthy. cass writes a digest incrementally, not at the end. go-to-damn-bed writes tomorrow.md and a wip commit before it lets you leave. poha closes offline commitments with one-tap email acknowledgments that the next briefing parses. aitne drafts a morning plan from calendar, mail, github, and notes. cagle turns daily changes into a structured github commit.
the agents that feel trustworthy are not smarter models. they are better handoffs.
the primitives are free. the supervisor is missing.
the model vendors have already shipped the raw execution layer. claude code supports cloud routines that run when the computer is off. github actions on cron. desktop scheduled tasks. the agent sdk. openai's agents sdk provides the loop, tools, state, tracing, guardrails, and resumable approvals.
the scheduling problem is solved. the compute problem is solved.
what nobody has solved: consent, scope, idempotency, cost governance, verification, rollback.
refract argues an autonomous coding agent will put a database query next to the component unless the repository enforces domain boundaries. arno recommends explicit layered dependencies and observable async work. ans has only run-level consent today, with host or url scoping planned but not built. loco-agent frames cost and access controls as the main differentiator.
the missing product is not a model. it is the policy and artifact layer above the model.
the move: one user, one durable state file, one morning brief
forget the platform. forget the infra project. the mvp is a skill plus a scheduled routine.
the 8pm shutdown routine stops new work. captures the day as a reviewable handoff. queues low-risk tasks for overnight. returns a morning brief with decisions front-loaded.
the evidence is there. accountability minus control equals burnout, so the design must not require a human to supervise an agent all night. the real skill is designing the handoff, not building the agent. users with adhd-like evening hyperfocus need externally enforced shutdown, not another motivational prompt. one subject reported tomorrow.md existing in three repos and mornings starting in ten seconds instead of twenty minutes.
ten seconds instead of twenty minutes. that's the metric that matters.
the takeaway
the agent that sends you to bed at 8pm is not less ambitious than the daemon that runs all night. it's more human. it respects the boundary. it captures the day. it runs the low-risk work. it returns a reviewable morning.
dom, build the handoff. not the daemon. the agent that tells you to stop, and gets more done while you sleep than you ever did at 2am, is the one that understands the work isn't the grind.
the work is the handoff. and the handoff is the moat.