Buffy API: Plug Your App Into the Behavior Engine

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:

Building Multi-Channel Bots on Top of One Behavior Core

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:

Memory Architecture for Long-Term Behavioral Coaching

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/message with identity, channel, and timestamp; the core returns intent, state updates, and reply content.
Activities: Use GET /v1/activities and PUT /v1/activities/:id to 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. End users trying Buffy as a product should start with How to Get Started With Buffy Agent in 5 Minutes.