The Problem
Operational debt accumulates faster than teams clear it
Stale PRs. Outdated issues. Untriaged errors. Rotting documentation. Aging dependencies. Engineering teams accumulate this work faster than they clear it.
The Problem
Stale PRs. Drifted issue metadata. Untriaged errors. Rotting documentation. Aging dependencies. Engineering teams accumulate this work faster than they clear it. Each task is too small for an engineer to prioritize, so the rational move for every engineer is to skip it. The result is a tragedy of the commons.
Operational debt is the maintenance work that accumulates across a codebase and everything around it — the project graph, the docs, the error inbox, the dependency manifest.
Planning suffers
Stale issues, incorrect labels, out of date priority fields. Every planning meeting starts with archaeology.
Onboarding drags
Documentation drifts from the codebase and is months out of date. New engineers learn outdated patterns and ship code that doesn't follow standards.
Bugs recur
Issues don't get triaged, and linger. The same alert patterns recur, get glanced at, and get dismissed.
Dependencies rot
Security patches accumulate. Minor bumps become major migrations. A one-line update becomes a migration project.
The Multiplier
Agents multiply the output.
Nobody multiplies the
maintenance.
Agents let teams ship more code, faster, which also creates operational debt faster. More code, more docs, and more issues to maintain.
The Multiplier
Agents can fix operational debt if you ask. But someone has to notice the problem, frame the task, and prompt the agent each time. The debt scales with the output. The human attention doesn’t.
Keeping a codebase healthy isn’t a task you finish. It’s an ongoing role. On most teams, nobody fills it.
| Task | Role | |
|---|---|---|
| Duration | Discrete | Continuous |
| Initiated by | A human prompt | The environment |
| Done when | Deliverable ships | Never |
| Example | “Fix this bug” | “Keep PRs mergeable” |
The Solution
What a daemon is
A daemon fills the maintenance role. You define the role once — what it watches, what it does, what it can’t do — and the daemon handles it from there.
The Solution
Daemons work in your team’s existing tools: GitHub PRs, Linear issues, Slack threads. No dashboard required.
The name comes from Unix: a long-lived background process that maintains system health. That’s what these do for engineering teams.
- Persistent
- Daemons are always running on cloud infrastructure, and accumulate context over weeks and months, getting sharper the longer they run.
- Self-initiating
- A PR is opened, CI fails, a Sentry alert fires. The daemon observes a condition and acts. No human prompted it. It reacts through configured watch conditions.
- Role-based
- Each daemon has one job: keep PRs mergeable, keep issues accurate, keep docs current, triage every bug.
Daemon Roles
A daemon for every domain
Each daemon has one job and a clear boundary around it. Narrow scope means predictable behavior and output your team can trust.
Daemon Roles
PR Helper
PRs sit for days. Descriptions drift from the diff. Merge conflicts pile up. CI fails on lint and formatting.
Conflicts get resolved. Failing checks get fixed. Descriptions match the diff. Humans review clean PRs.
Project Manager
Issues have the wrong status, labels are missing, priorities get stale. Planning always starts with cleaning up the mess from the last iteration.
Metadata reflects reality accurately. Blockers are surfaced before standup. Planning becomes data-driven, not reactive.
Bug Triage
Error tracker alerts are ignored or dismissed, and the same errors recur. No root cause analysis is possible.
Every error gets triaged within minutes. Recurring patterns get connected. Issues arrive with root cause analysis and reproduction context.
Codebase Maintainer
Dependencies age. Security patches pile up. Minor bumps become major migrations.
Dependencies stay up to date. Security patches are promptly applied. PRs arrive tested and ready.
Librarian
Docs drift within weeks. READMEs describe APIs that no longer exist.
Docs stay current. Stale content gets caught and updated. New engineers read docs that match the code.
The Flywheel
Daemons compound
Every action a daemon takes is one a human didn’t have to notice, decide on, and initiate. That overhead disappears permanently. The operational debt shrinks instead of growing.
The Flywheel
-
Zero marginal attention
Agents need a human to notice, frame, and prompt every time. Daemons act on their own. The hundredth action costs the team nothing.
-
Learn norms
Over weeks, the daemon builds a model of your team’s conventions: labeling schemes, review preferences, escalation patterns. It stops needing correction.
-
Earn trust
The daemon file is a spec in your repo. The team tunes it like any other config: tighten a threshold, add a deny rule, narrow the scope. Predictable behavior earns autonomy.
-
Reinforce each other
Each daemon’s output is input for the others. Clean PRs mean accurate project data. Triaged bugs mean targeted fixes. More daemons, better signal.
Eventually, you forget they're running. That's the daemon working.
Landscape
Daemons vs. everything else
Daemons aren’t a replacement for coding agents. They fill the gap agents leave behind.
Landscape
A local agent starts when you type a prompt in your terminal. A cloud agent starts when you assign it a task. Both wait for a human to decide something needs doing. A daemon starts when something happens in the environment — a PR is opened, CI fails, a Sentry alert fires.
Agents excel at novel work: building features, designing APIs, refactoring modules. The problem is different every time, so a human frames it. Daemons excel at ongoing work: the judgment is real, but the pattern is known and a daemon file can encode it once. Use agents to build. Use daemons to maintain what you’ve built.
| Human-initiated | Self-initiated | |
|---|---|---|
| Isolated | Local agent (Claude Code, Codex CLI) | |
| Shared | Cloud agent (Devin, Codex) | Daemon |
Conclusion
Agents help teams ship more, faster, which also means more operational debt, faster. The maintenance scales with the output. The human attention doesn’t. That’s a role, not a task, and on most teams nobody fills it.
Daemons do, without adding to anyone’s workload. A PR Helper keeps PRs mergeable. A Bug Triage daemon triages errors within minutes. A Librarian keeps docs in sync with the code. They run continuously in the background, learning your team’s norms and acting on what they find. No prompt. No reminder. No human in the loop.
Agents create work. Daemons maintain it.