Most tools that promise “better habits” or “more focus” give you a dashboard, a streak counter, and a notification schedule. You set everything up, feel good for three days, then life happens and the system quietly falls apart.
Buffy is built as a personal behavior agent, not another habit app. Instead of asking you to move your life into a new tool, it sits next to you across ChatGPT, Telegram, Slack, and your own apps, coordinating habits, tasks, and routines through one behavior core and memory system.
This playbook walks you through a minimal, real-world setup:
What you’ll do in this guide
- Set up one small routine (or habit) that’s actually likely to stick.
- Give Buffy enough structure to help (activity + time window + channel).
- Run it for a week, then adjust based on what actually happened.
If you want the conceptual background first, you might like:
- What Is Buffy Agent?
- Habit Tracker vs. Personal Behavior Agent
- Designing a Personal Behavior Agent for Habits, Tasks and Routines
Step 0: What is a personal behavior agent (in practice)?
Before we start, a quick definition in product terms, not architecture diagrams:
Definition: personal behavior agent
A personal behavior agent:
- treats everything you want to change as an activity (habits, tasks, routines)
- lives across multiple channels (ChatGPT, Telegram, Slack, internal bots)
- keeps event history and patterns so it can adapt over time
- helps you design and maintain behaviors with just enough reminders
Buffy’s behavior core is where that logic lives. Each interface (ChatGPT, Telegram, Slack) is a thin adapter that talks to the same engine. That’s what makes the playbook below work without adding “one more app.”
Step 1: Pick one behavior (not five)
Most systems fail because they start too big:
- 7 habits.
- 3 routines.
- All at once, starting Monday.
The playbook starts smaller: one behavior that is easy to win with.
Good candidates:
- “Drink water after I wake up.”
- “10 minutes of planning before work.”
- “Close the day with a 3‑bullet reflection.”
- “Check tomorrow’s calendar at 16:30.”
If you’re drawn to routines, that’s fine—just keep the routine tiny:
- “Morning startup: water + 5‑minute plan.”
- “Evening shutdown: write tomorrow’s top 3.”
You can always expand later. Buffy’s behavior engine works best when it can learn from clear, repeated patterns, not a chaotic to‑do list.
Step 2: Give the agent a clean sentence
Buffy is designed to understand natural language and turn it into structured activities. You don’t need a config screen; you need one good sentence.
In ChatGPT (or your Buffy entry point), say something like:
“Weekdays, create a morning startup routine with water and a 5‑minute planning block between 7:30–8:00.”
This gives the agent enough structure to work with:
- Type: routine (with nested habits).
- Schedule: time window on weekdays.
- Context: “morning startup” (something you’ll recognize later).
Under the hood, Buffy turns that into:
- A routine activity (“Morning startup”).
- Two habit activities inside it (“Drink water”, “5‑minute planning”).
- A time window (7:30–8:00) instead of a brittle 7:45 alarm.
You can use the same pattern for a single habit:
“Weekdays, remind me to drink water between 8:00–8:30.”
Step 3: Choose your execution channel
Planning and execution rarely happen in the same place:
- You think and design in ChatGPT.
- You execute in Telegram (on your phone) or Slack (at work).
This is a feature, not a bug. The playbook leans into it.
Pick one primary execution channel:
- Telegram if you want personal nudges on your phone.
- Slack if you want work‑day routines or team‑adjacent habits.
Tell Buffy (in ChatGPT is fine), e.g.:
“Use Telegram as my primary channel for reminders about this routine.”
Or:
“Keep personal routines in Telegram, and anything tagged as team in Slack.”
Buffy’s behavior core doesn’t “live” in Telegram or Slack; those are interfaces. But choosing a primary execution channel helps the Reminder Engine make good defaults.
For more on this split, see:
- ChatGPT for Planning, Telegram for Execution: A Multi-Channel Agent Workflow
- Habit Tracking in Telegram: One Bot, Same Behavior Engine
- How Teams Use Buffy Agent Together in Slack
Step 4: Run the experiment for one week
For the first week, your job is deliberately small:
- When Buffy nudges you:
- Do the thing, or
- Reply honestly (
done,snooze 20,skip today, “too busy”).
That’s it.
The goal of week one is not perfect behavior. It’s data:
- When do you usually complete the routine?
- When do you tend to snooze or skip?
- Does Telegram actually work better than Slack for this?
Buffy’s memory system keeps track of:
- Episodic events (what actually happened).
- Early semantic patterns (what seems to be true so far).
That’s what lets the agent become calmer and smarter over time instead of spammier.
If you’re curious about that side, there’s a deeper dive here:
Step 5: Adjust the system, not your willpower
At the end of the week, ask Buffy (or yourself) a few simple questions:
- “Did this routine mostly happen?”
- “When did it fail—and why?”
- “Is the time window realistic?”
- “Is the channel right?”
Then make one small adjustment, using buffs like:
Option A: Shrink the behavior
If the routine is too ambitious:
- Turn “morning startup: water + plan + stretch” into:
- “water + 3‑bullet plan” for now.
In natural language:
“Shrink my morning startup routine for next week: water + 3‑bullet plan only.”
Option B: Move the window
If mornings are chaotic:
- Move the time window or make it looser:
“Move my morning startup window to 8:30–9:00 on weekdays.”
Or:
“Make this ‘any time before lunch’ instead of a fixed morning window.”
Option C: Change the channel
If reminders in Slack are getting lost:
“Move reminders for this routine from Slack to Telegram.”
Or the reverse, if it’s work‑related and belongs in your team context.
The important part: treat misses as data, not failure. You’re iterating on a behavior system, not judging yourself.
Step 6: Add one more layer when it feels light
Only after the first behavior feels lightweight and reliable should you add anything.
Good “second steps”:
- Turn a habit into a routine:
- Add one small step to an existing window (e.g. “add a 2‑minute stretch to morning startup”).
- Add a weekly routine:
- “Friday afternoon: 10‑minute weekly review” with a summary prompt.
- Add a blocking task:
- “Every Thursday, remind me to prep slides for Friday’s standup.”
Each new layer should:
- Reuse an existing channel (don’t add more surfaces yet).
- Reuse an existing window or time of day where possible.
- Feel like a small extension, not a new project.
This is where Buffy’s unified Activity model starts to pay off:
- Habits, tasks, and routines share the same structure (schedule + context + history).
- Daily briefings and reminders can now see across them.
A quick checklist: are you using Buffy as a behavior agent yet?
Use this as a quick self‑check:
- [ ] Do you have at least one activity (habit or routine) defined as a window, not just a fixed alarm?
- [ ] Does Buffy live in the same channels where you already work (ChatGPT + Telegram/Slack), not in a separate app?
- [ ] Have you run one behavior for a full week, replying honestly when you couldn’t do it?
- [ ] Have you made one adjustment based on what actually happened (shrink, move window, or change channel)?
- [ ] Does your setup feel lighter than your old apps, not heavier?
If most of these are “yes”, you’re already using Buffy as a personal behavior agent, not just a tracker.
Where to go next
- Next step: if you haven’t yet, walk through the step‑by‑step quickstart and set up your first activity in minutes:
How to Get Started With Buffy Agent in 5 Minutes