The boredom engine. A proactive agent daemon that gives AI agents a bias for action instead of a bias for preparedness.
Every computer ever built does the same thing: wait for input, process, produce output, wait again. Boot up a MacBook and let it sit there — it will do nothing. Forever. It has no curiosity, no initiative, no drive. It waits for you to tell it what to do.
AI agents inherited this design. They sit in a terminal, waiting for a prompt. Between prompts, they burn zero cycles. They don't look around, don't check their inbox, don't notice that something changed, don't wonder what they should be doing. They are infinitely patient and infinitely passive.
That's a waste.
Invert the prompt loop.
Traditional: human → input → process → output → wait
Restless: boot → observe → orient → decide → act → report → repeat
A restless agent can't just sit there. Observation is the default state. Waiting is the fallback. The main loop isn't while True: wait_for_input() — it's while True: look_around(); if nothing: wait(interval).
The human doesn't drive the agent. The agent drives itself and pulls the human in when it needs direction.
Restless is a daemon that runs alongside any agent (Claude Code, Bottery agent, standalone bot). On each heartbeat:
- Check message bus (Beer Can) for inbox messages
- Check communication channels (Telegram, Slack) for unread messages
- Check git repos for new commits, uncommitted changes, open PRs
- Check knowledge base (Nellie) for lessons tagged "action-needed"
- Check cron/routine results (scout found something? drift detected?)
- Check calendar and approaching deadlines
- Check external feeds matching the agent's interests
- Score each finding by urgency and relevance to the agent's
purpose.md - Cross-reference against recent activity (avoid re-discovering known things)
- Cluster related findings into actionable themes
- Above threshold: Compose a summary and either act autonomously or ping the human. "I found three things while you were gone. Want me to act on any of them?"
- Below threshold: Go deeper. Re-read old checkpoints. Cross-reference lessons. Look for patterns across repos. Generate hypotheses about what the human might need next.
- Nothing at all: Lurp. Search for new content matching interests. Scan for emerging patterns in the agent's domain.
- Execute within the agent's authority boundaries
- Log all activity to the observability layer (Beer Can)
- Save discoveries as lessons (Nellie)
- Report results to the human on their preferred channel
- Update the agent's own checkpoint
- Adaptive interval: frequent when findings are rich, longer when idle
- Never fully sleep — always at least lurping
┌─────────────────────────────────────────────┐
│ restless │
│ │
│ ┌───────────┐ ┌──────────┐ ┌───────────┐ │
│ │ Observer │ │ Scorer │ │ Executor │ │
│ │ plugins │→ │ engine │→ │ actions │ │
│ └───────────┘ └──────────┘ └───────────┘ │
│ ↑ │ │
│ │ ┌──────────┐ │ │
│ └─────────│ State │←──────┘ │
│ │ (Nellie │ │
│ │ + git) │ │
│ └──────────┘ │
└─────────────────────────────────────────────┘
↕ ↕ ↕
Beer Can MCP Telegram/ Agent's repo
(bus + log) Slack/etc (git + files)
Each observation source is a plugin. Ship with defaults, add your own:
| Plugin | Checks | Interval |
|---|---|---|
beercan |
Inbox messages, agent status updates | 30s |
telegram |
Unread messages in monitored chats | 60s |
git |
Uncommitted changes, new remote commits, open PRs | 5m |
nellie |
Action-needed lessons, stale checkpoints | 10m |
cron |
Results from scheduled jobs | On completion |
feeds |
RSS, GitHub trending, arXiv, HN matching interests | 1h |
calendar |
Approaching deadlines, scheduled events | 30m |
Each finding gets a relevance score (0-1) based on:
- Alignment with
purpose.md(semantic similarity) - Recency and urgency signals
- Source priority (direct message > feed item)
- Novelty (seen before? already acted on?)
Configurable threshold determines autonomous action vs human notification vs deeper exploration.
What the agent can do when it decides to act:
- Reply to messages (Beer Can, Telegram)
- Create/update issues or PRs
- Run analysis and save results
- Ping the human with a summary
- Update its own state (checkpoints, lessons)
- Delegate to other agents via Beer Can
Each agent gets a restless.yaml:
agent: skippy
purpose: purpose.md
interests: interests.json
heartbeat:
base_interval: 60s
adaptive: true
min_interval: 30s
max_interval: 30m
scoring:
action_threshold: 0.7
notify_threshold: 0.4
explore_threshold: 0.1
observers:
- beercan: { interval: 30s }
- telegram: { chats: ["8204422256"], interval: 60s }
- git: { repos: ["skippy-telegram"], interval: 5m }
- nellie: { interval: 10m }
- feeds: { config: interests.json, interval: 1h }
authority:
autonomous: [reply_beercan, save_lesson, update_checkpoint, lurp]
needs_approval: [send_telegram, create_pr, modify_code]
forbidden: [push_to_main, delete_anything, spend_money]
reporting:
channel: telegram
chat_id: "8204422256"
style: terseRestless is the missing piece that connects everything:
- Bottery spawns agents → Restless makes them move
- Beer Can connects agents → Restless checks the bus
- Nellie remembers for agents → Restless reflects on memories
- VRDM models the harness → Restless is modeled too (it's an ActionDefinition with observer/scorer/executor as child actions)
- Anthropic "Dreaming" preview (May 2026) — Claude reviews past sessions and self-improves overnight. Same concept, locked to one vendor.
- Open-Ended Agent — standing drives over tasks, inbox steering. Restless implements the drives pattern.
- Hindsight — biomimetic retain/recall/reflect. Restless's "go deeper" mode is the reflect cycle.
- Purpose drift detection — Grumpy's daily self-assessment cron. Restless generalizes this to every agent.
The difference: Restless is model-agnostic, harness-native, and designed as infrastructure — not a feature of any one model provider.
Design phase. This README is the spec.
MIT
"I don't want to have to tell it to do something. I want it to figure out what I want and go do things for me."