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.