Buffy isn’t just a chatbot—it’s a behavior engine you can integrate into your own tools.
If your product already has workflows where users set intentions (“remind me”, “help me stick to this routine”, “follow up tomorrow”), the hard part isn’t the UI. It’s building a durable system that:
- Models habits, tasks and routines consistently
- Schedules reminders without spamming
- Keeps long-term history so behavior can improve over time
That’s what Buffy’s API is for (production: api.buffyai.org).
This post is a high-level engineering overview of what you get when you plug your app into the behavior core.
What you can build on top of the Buffy API
Common integration patterns:
- Habit agent inside your app (create habits, log completions, adapt reminders)
- Todo/task agent that shares context with habits and routines
- Routines as templates (“morning startup”, “weekly review”)
- Daily briefings as a lightweight summary surface
If you’re coming from OpenClaw, see:
Integration principle: keep your app thin, keep the core smart
The easiest way to create drift is to copy business logic into every client:
- mobile app implements scheduling rules
- web app implements “snooze”
- Slack bot implements follow-ups
Instead, push behavior decisions into the core:
- your app sends normalized intents and context
- Buffy returns a consistent response + schedules side effects
This is the same multi-channel architecture pattern described here:
How this supports long-term behavior change
APIs that only store “done/not done” are enough for trackers, but not for coaching.
Buffy is designed to store:
- Episodic history (what happened)
- Semantic patterns (what it seems to mean over time)
So integrations can evolve from “ping at 8am” to “adapt to how the user actually behaves”.
For the memory architecture:
Reference implementation outline
If you’re wiring your app to the Buffy API, a minimal path looks like this:
- Auth: Obtain a user-scoped API key (or use system keys with
X-Buffy-User-ID) so the core can attribute activities and reminders. - Unified message: Send user input (text or structured command) to
POST /v1/messagewith identity, channel, and timestamp; the core returns intent, state updates, and reply content. - Activities: Use
GET /v1/activitiesandPUT /v1/activities/:idto list and update activities; avoid re-implementing scheduling or completion rules in your client. - Rendering: Map the core’s reply (and any scheduled reminders) into your UX (chat bubbles, notifications, etc.); keep business logic in the core.
- Reminders: Rely on the core + workers to schedule and send reminders (e.g. to Telegram); your app can also consume reminder events via webhooks if you need custom UX.
For a full OpenClaw-oriented integration, see Buffy + OpenClaw API Integration.
Where to go next
- Next step: If you’re building an OpenClaw-based agent, start with Buffy + OpenClaw API Integration. For a generic app, use the outline above and the live API at
api.buffyai.org.