Skip to main content
These examples are adapted from a real ollim-bot data directory. They show how routines, reminders, chains, and embeds compose into a daily system. Personal details have been scrubbed.

​
Daily rhythm

A single user’s routines/ directory can define an entire day. Here’s how 17 routines and a handful of reminders fit together: Weekly additions: fitness review (Sun 9 AM), sleep review (Sun 9:30 AM), music review (Sun 10 AM), responsiveness review (Sun 6 PM), weekend planner (Thu 5 PM).
Every routine here is background: true — see background forks. The agent works silently and only reaches out via discord_embed or ping_user when it has something worth saying, governed by the ping budget. Some routines (like identity stabilize) never ping at all.

​
Routines

​
Morning briefing — multi-step dashboard

The most complex routine. It gathers data from multiple sources in parallel, creates tasks from findings, schedules reminders for time-critical items, and sends a single dashboard embed with action buttons.
routines/morning-briefing.md
Key patterns:
  • Parallel enrichment — core steps always run; enrichment steps are best-effort and skipped on failure
  • Graceful degradation — the embed always sends, even with partial data
  • Duplicate prevention — checks existing reminders before scheduling new ones
  • Cap overwhelm — limits “needs a deadline” suggestions to 2-3 items
  • Subagent delegation — uses the user-proxy subagent to make judgment calls (prioritization, rescheduling dates) that benefit from simulating user preferences
  • Escalating overdue handling — overdue tasks get progressively more assertive treatment rather than nagging indefinitely

​
Workout nudge — embeds with buttons and follow-up chains

Sends a weather-aware workout suggestion with interactive buttons, then schedules a 2-hour follow-up chain to check in.
routines/workout-nudge.md
Key patterns:
  • Agent buttons — each button’s action is an agent:<prompt> that tells the interactive fork what to do when clicked
  • Adaptive button set — active recovery omits Harder/Easier; runs omit Choose Exercises
  • Follow-up chain — the routine itself schedules a chain reminder to check back later
  • report_updates is critical — without it, the main session can’t handle button clicks (“Harder” with no workout context)

​
Nightly sleep — dynamic single-reminder scheduling

A silent scheduler routine that reads sleep data, calculates a bedtime, and schedules a single reminder timed to it.
routines/nightly-sleep.md
Key patterns:
  • Routine creates reminders — the routine itself never pings; it calculates timing and schedules a reminder that does
  • Self-contained reminder prompt — the reminder must carry all context since it runs in a fresh fork
  • Dynamic timing — the delay is computed from sleep data, not hardcoded
  • Data-driven scheduling — prescribed bedtime adjusts weekly based on sleep efficiency metrics
  • Minimal nudge — a single ping_user line, not an embed or chain. Lower friction means less annoyance at bedtime

​
Chore time — low-friction ADHD nudge

A simple routine designed around ADHD — lower the bar to “one thing, 15 minutes” instead of listing everything that needs doing.
routines/chore-time.md
Key patterns:
  • Behavioral design — the prompt encodes knowledge about the user’s ADHD and designs the interaction around it
  • Chain length by urgency — more urgent tasks get longer chains
  • Checks before scheduling — checks reminder list to avoid compounding chain reminders

​
Email check — conditional silence

A quiet background routine that only pings when something is genuinely urgent. Most runs produce no notification at all.
routines/email-check-morning.md
Key patterns:
  • Time-based dedup — ignores emails before 8:30 AM because the morning briefing already handled them
  • Conditional ping — strict criteria for when to notify; defaults to silence
  • Content boundary — explicit instruction to treat email as data, preventing the bot from being tricked by instructions hidden in emails

​
Self-reflection — observation-only meta-routine

A meta-routine that reviews the bot’s own behavior. It runs before the morning briefing and feeds findings into it, but takes no action itself.
routines/self-reflection.md
Key patterns:
  • Routine pipeline — self-reflection runs at 8:00 AM, morning briefing at 8:30 AM. The briefing receives the finding via report_updates (prepended as pending updates)
  • Single finding — avoids information overload by surfacing only the highest-impact issue
  • No side effects — explicitly prevented from creating tasks or scheduling reminders to avoid double-processing

​
Identity stabilize — silent maintenance

A high-frequency maintenance routine that keeps a core profile file accurate. Runs every 4 hours, never pings, and uses the cheapest model.
routines/identity-stabilize.md
Key patterns:
  • model: "haiku" — uses the cheapest model since this is simple file maintenance
  • allow-ping: false — can never notify the user; purely background
  • update-main-session: "freely" — reports updates only when changes are made, so the main session stays informed without noise
  • Freshness protocol — date-tagged facts with automatic staleness pruning
  • Conservative edits — only changes what has evidence; if the history-reviewer subagent fails, the routine does nothing

​
Reminders

​
One-shot reminder — time-sensitive errand

A simple time-based nudge for a real-world errand. Created by the agent during conversation when the user mentioned a pickup.
reminders/cake-pickup-reminder.md
Key patterns:
  • No description needed — the message is self-explanatory
  • Agent-created — the user mentioned the pickup in conversation; the agent scheduled the reminder automatically
  • Precise timing — run-at is an exact ISO datetime computed from a delay

​
Future-dated reminder — scheduled weeks out

A reminder scheduled far in advance for a recurring financial event. The detailed message ensures a fresh agent fork has full context.
reminders/token-thaw-reminder.md
Key patterns:
  • Self-contained context — the reminder includes everything a future agent needs (batch number, remaining count, action to take)
  • Background by default — runs in a background fork and pings via ping_user for maximum visibility on a financial deadline. Add background: false if you prefer a direct DM instead
  • Far future — scheduled 6 weeks out; the scheduler handles dates far in the future without any special configuration

​
Chain reminders and single reminders — spawned by routines

Routines schedule reminders dynamically. Some use chains for progressive follow-up, others use a single fire-and-forget reminder:
Chain steps can call follow_up_chain(minutes_from_now=N) to schedule the next step, or end the chain by not calling it. Single reminders (no --max-chain) fire once and self-remove.

​
Patterns worth noting

​
Routine pipelines

Routines can feed into each other via report_updates:
The self-reflection routine is explicitly prevented from taking action so the morning briefing — which has the full picture — can make better decisions.

​
Conditional silence

Most background routines default to silence. They only ping when criteria are met:
  • Email checks: ping only for urgent, human-sent, actionable mail
  • End-of-day: silent if nothing is overdue or due
  • Responsiveness review: silent if all reminders are working well
  • Identity stabilize: allow-ping: false — can never notify
This is the opposite of a notification-heavy system. The ping budget provides a hard cap, but well-designed routines rarely hit it.

​
Behavioral design in prompts

Routines encode knowledge about the user’s needs directly in the prompt:
  • Chore time: “ADHD makes starting the hardest part — lower the bar”
  • Morning briefing: “cap at 2-3 suggestions because more is overwhelming”
  • Workout nudge: “no guilt” skip option on every workout
  • Music practice: “feel like a friend nudging, not a task manager”

​
Chain reminders for progressive nudging

Chains create multi-step follow-up sequences without open-ended loops:
  1. Workout: suggest → 2h check-in → offer quick version (max 2)
  2. Chores: nudge → 1h check-in → gentle reminder (max 2)
  3. Music: suggest → 90-min check-in (max 1)
Each step checks whether the user already responded and stays silent if so — chains are nudges, not nags. Not everything needs a chain. The nightly sleep routine schedules a single bedtime ping — no follow-up, no chain. A one-line ping_user at the right moment is less annoying than a sequence of embeds.

​
Bot-authored logic

The routines on this page weren’t hand-written — the bot created them through conversation. You describe what you want, give feedback on what it builds, and iterate until it works the way you need. The bot handles the YAML configuration, prompt logic, button interactions, follow-up chains, and cross-routine coordination.

​
How the workout routine was created

The conversation started with:
The bot built an initial version, but getting to the final routine took several rounds of back-and-forth — adjusting the workout rotation, tweaking button options, refining follow-up timing, and adding weather logic. Over that conversation the bot:
  1. Gathered context — read existing routines to understand the scheduling pattern, checked what profile data existed
  2. Created a fitness profile — wrote ~/.ollim-bot/fitness-profile.md with stats, goals, and available equipment (sourced from conversation history)
  3. Designed the interaction — chose Discord embeds with buttons over plain messages for richer feedback loops
  4. Iterated on the prompt logic through feedback until it encoded:
    • A 7-day workout rotation with muscle group balancing rules
    • Weather-aware indoor/outdoor logic
    • Exercise progressions (harder/easier variants)
    • A condensed 15-minute version for busy days
    • A multi-step “choose exercises” flow with muscle group picker
    • A 2-hour follow-up chain that stays silent if already completed
  5. Wired up report_updates so button clicks in the main session have full context about which workout was suggested
The result is the workout nudge routine shown above — a routine that evolved through conversation into something that adapts to weather, calendar, recent workout history, and real-time user feedback through buttons.

​
What this means

Every routine prompt is executable logic. When a background fork fires, the agent reads the prompt and executes it as a program — gathering data, making decisions, building UI, and scheduling follow-ups. The bot is effectively programming itself: compiling your requirements into natural language instructions that its future instances interpret and run. This works because of three properties of the system:
  • Skills let the bot write shared function libraries — a SKILL.md file read by multiple routines acts like an imported module
  • Background forks run prompts in isolated sessions, so each execution is a fresh “function call” with defined inputs (the preamble) and outputs (report_updates, discord_embed, follow_up_chain)
  • Chain reminders let the bot schedule its own continuations — recursive self-invocation with context passing
You don’t need to understand how to write routines. Start with what you want — “remind me to stretch every 2 hours but not during meetings” — and refine from there. The bot builds an initial version, you give feedback, and it iterates. The examples on this page show the end result of that process, not one-shot outputs.

​
Next steps

Routines

Cron syntax, YAML frontmatter fields, and management commands.

Reminders

One-shot reminders, delay scheduling, and follow-up chains.

Background forks

Isolated mode, model overrides, tool restrictions, and update modes.

Ping budget

How notification rate limiting works for background tasks.