Agents create work.
Daemons maintain it.
Keep PRs mergeable, documentation accurate, issues up to date, and bugs out of production with a new type of AI background process that is self-initiated and defined in easy-to-use .md files.
--- name: pr-helper purpose: Keeps PRs review-ready. watch: - when a pull request is opened - when a pull request is synchronized routines: - suggest PR description improvements - flag missing reviewer context deny: - merge pull requests - push to protected branches schedule: "0 9 * * *" --- ## Policy Focus on short, actionable feedback. ## Output format 1. Findings 2. Suggested edits 3. Questions for author
- What's in a Daemon .md file?
- Daemons are defined in Markdown files that live in your repo. You define the role once — what it watches, what it does, what it can't do — and the daemon handles it from there.
- Frontmatter
-
Declarative fields between
---fences define what the daemon is: its name, purpose, watch conditions, routines, deny rules, and schedule. - Content
-
Markdown below the
---frontmatter defines how the daemon operates: policy, output format, escalation rules, limits, and more. - Portable
- Daemon files are an open format. The same file works across any provider that supports the spec.
Where Daemons fit in
Agents are human-initiated. Daemons are self-initiated — they observe the environment, detect drift, and act without a prompt.
GitHub Linear Sentry Slack Docs
|
v
+------------------------------------------------+
| AGENTS (human-initiated) |
| Build features, fix bugs, ship code |
+------------------------+-----------------------+
|
+-------------+--------------+
| Code, PRs, Issues, Docs |
| drift accrues here |
+-------------+--------------+
|
+------------------------------------------------+
| DAEMONS (self-initiated) |
| Watch, detect, fix, repeat. No prompt needed. |
| |
| > Resolve merge conflicts |
| > Update stale documentation |
| > Triage and assign bugs |
| > Patch outdated dependencies |
| > Label and organize issues |
| > Fix failing CI checks |
+------------------------------------------------+ Daemons do the work that agents leave behind
Operational debt is the new technical debt. Daemons pay it down.
Debt accumulates
Operational debt accrues in your Linear issues, GitHub PRs, dependencies, and more, creating serious drag and reducing overall quality.
Agents accelerate it
Agents help teams ship faster, which creates operational debt faster too. More code, more docs, and more issues to maintain.
Daemons maintain it
A daemon fills this 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.
Daemons are defined in Markdown files that you can modify, create, and share
Project Manager
Keep your issues up to date
Bug Triage
Watch your bug tracker and prevent reoccurrences
Codebase Maintainer
Keep dependencies up to date and patches in place
Librarian
Keep your documentation accurate so onboarding is not a wild goose chase
--- name: issue-labeler purpose: Ensures every Linear issue has the correct labels from the type and touchpoint label groups. watch: - when a Linear issue is created routines: - add missing labels to a new Linear issue - find issues with missing labels and add them deny: - remove labels from issues - replace or change existing labels on issues - comment on issues - change issue status, priority, assignee, or any field other than labels schedule: "0 2 * * *" --- ## Policy - Only add labels. Never remove, replace, or overwrite existing labels. - If an issue already has a label from a group, do not touch that group. - Apply the single best-fit label from each missing group. ## Limits - On issue-created events, process only the triggering issue. - On the daily sweep, label at most 20 issues per activation.
- Hybrid activation
- Wakes on new issues and sweeps daily to catch anything missed.
- Additive only
- Deny rules ensure the daemon can only add labels, never remove or change existing ones.
- Rate-limited
- Limits section caps work per activation so the daemon doesn't overwhelm reviewers.
Predictable and reliable autonomy
Daemons excel at ongoing work. Use agents to build, and use daemons to maintain what you've built.
Work you didn't have to notice
Every action a daemon takes is one a human didn't have to notice, decide on, and initiate.
Specialized and improving
Daemons perform specific roles, get better over time, and always follow your team's conventions.
Predictable behavior earns trust
Encode your preferences and style once, and daemons will keep things tidy. Predictable behavior earns autonomy.
Define a role, not a task
A task has a start, an end, and a definition of done. A role is an ongoing responsibility with judgment. The daemon file is a role description.
Compounding control
Every daemon file edit changes behavior across every future activation for the whole team. Each change is small, but the effects multiply.
Direction once, not every time
Agents require direction every time. Task 500 costs the same human attention as task 1. Daemons require direction once, then less and less over time.
Accumulating context
Daemons build a richer model of the team and codebase over time. A daemon at month three is sharper than at day one, without anyone updating a file.
Always on and easy to use
Local agents need your laptop to run, and cloud-based agents can be flaky and unpredictable.
Config in your repo
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.
Continuous observation
Daemons run continuously in the background, observing where work happens — in GitHub, Linear, Slack, and more.
Zero maintenance
Daemons run smoothly and execute reliably, without having to stare at logs, monitor uptime, or restart processes manually.
Eventually, you forget they're running. That's the daemon working.
Build your own daemons with our flexible specification that anyone can use
Daemons don't complete tasks — they fulfill roles. Create your own now.
"The Charlie Daemons are working very, very well, both for commenting and cleaning things up in Linear as well as the event-based actions in GitHub. We're moving so f@#$ing fast with agents that it's really great to have Daemons watching our backs to make sure we can keep up the accelerated pace."