Show HN: Daemons – we pivoted from building agents to cleaning up after them

# Agents create work. Daemons maintain it. | Charlie Labs Source: [https://charlielabs.ai/](https://charlielabs.ai/) 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\.FrontmatterDeclarative fields between`\-\-\-`fences define*what*the daemon is: its name, purpose, watch conditions, routines, deny rules, and schedule\.ContentMarkdown below the`\-\-\-`frontmatter defines*how*the daemon operates: policy, output format, escalation rules, limits, and more\.PortableDaemon 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 activationWakes on new issues*and*sweeps daily to catch anything missed\.Additive onlyDeny rules ensure the daemon can only add labels, never remove or change existing ones\.Rate\-limitedLimits 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/)