# Agents create work. Daemons maintain it. | Charlie Labs 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 They Fit ## 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 | +------------------------------------------------+ ``` The Problem ## 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. Daemon Library ## 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. Autonomy ## 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. Infrastructure ## 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.** Open Format ## 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." — Jasper Croome, [aarden.ai](https://aarden.ai)