Your best merchandiser has a morning routine. Before the store wakes up, they check which products went live overnight without a description, flag the ones priced below floor, and fix what they can. It takes an hour, it depends on them being at their desk, and it walks out the door the day they do.
Now imagine writing that routine down once, in plain English, and having it run every morning on its own, under that merchandiser’s own permissions, with a record of everything it touched. That is a Kibo Playbook: a saved, plain-language prompt that watches, reasons, and acts on the work your team already does. You describe the outcome once. Kibo runs it for you, on demand or the moment something happens, for as long as you like.
Why you can hand it real work
The obvious question about any software that acts on your store is why you would trust it to. The answer is the whole point of how Playbooks are built. A Playbook is never a loose model wired to your data. It runs inside Kibo’s harness, and the harness is what makes it safe.
Every Playbook runs under its author’s own credentials and permissions, so it can never do anything its author could not do by hand. It acts only through native tools Kibo builds and governs, so the prompt never touches a raw API, and none of those tools delete, so the worst case of a mistake is a recoverable change, not a lost one. Anything that would change data stops for human approval first. And every run is written to a record you can inspect afterward. Authority lives in the platform, not in the prompt. The model proposes; the platform decides.
This is the part the industry took two years to learn. For agents that do real work, the model is not the hard part. The thing wrapped around it is: the tools it can reach, the data it is grounded in, the permissions it runs under, and the proof it leaves behind. Kibo bet on that harness, which is exactly why a Playbook is safe to trust with a morning routine that touches live pricing.
Not a catalog of automations.
The engine that writes them.
Most platforms answer the automation question by shipping a fixed catalog of canned workflows, a closed set of checks someone else decided you needed. Kibo ships something different: the runtime that lets your own team author its own automations, over the same commerce and OMS operations you already work with, expressed as a prompt instead of a rigid if-this-then-that rule.
That distinction matters more than it sounds. A rules engine can only check a condition. A Playbook can judge one. Because the reasoning is AI-driven, it can weigh “is this description thin?” or “is this discount unusually large?” and respond in plain language, which no rulebook can do. Rules check. Playbooks decide.
Each user authors and owns their own Playbooks, like a personal workspace of delegated tasks. Over time your team builds up something like a workforce of small, reliable operators, each responsible for one job it would otherwise fall to a person to remember.
A quick reminder: the functions underneath
Playbooks put Kibo AI’s functions to work. There are five, each a different kind of work: Configure changes settings and rules in natural language, Explain answers why something happened in plain language, Analyze surfaces trends and anomalies across the full commerce and OMS data, Optimize predicts demand at the SKU-location level across a rolling 14-day horizon to keep customer promises and cut stockouts and split shipments, and Engage handles conversational shopper interactions. Today Playbooks work across three of them: Configure, Explain, and Analyze.
How a Playbook works: five steps
Every Playbook moves through the same five steps. Not every Playbook uses all of them, but the full path looks like this.
Trigger
Runs on a Kibo event, a schedule you set, or a manual run on demand. An event like order.created or product.created is best for real-time work and avoids scanning everything. A schedule fits continuous sweeps, like auditing live promotions each night. A manual run covers the simplest case of all: a saved prompt you keep on hand and fire whenever you need it.
Reason
Applies AI judgment, not rigid rules, to weigh what’s happening and decide what to do. It reads the relevant data, judges what it finds against your intent, and works out whether anything needs to happen and what that should be, in plain language a rules engine could never produce.
Alert
Flags the decision or problem for a human to review before anything changes. This is the human-in-the-loop step, and for changes it is not optional: any Playbook that would alter data always pauses for approval before it executes. The person sees the affected records and the values the Playbook proposes, and approves, edits, or rejects them with one click. An alert is not a separate inbox to manage. It is the run itself, surfaced for attention.
Complete
Carries out the decision: updating data, running the fix, or handing off to another system. A Configure action writes the change, for example a product description drafted in your brand voice. An Explain or Analyze action narrates and writes nothing. A Playbook can also pass its result to an application you have already registered, pushing a discount explanation into Slack or an enriched record into another system, or it can simply return the answer to you. It does all of this through Kibo’s governed tools, never a raw API, and never a delete.
Keep
Every run is logged into an audit trail: what it saw, what it changed, and who approved it. That record is the Playbook Run, and it is the system of proof. Alerts are simply a view over these runs, one flagged for attention, so “what happened” and “what needs my attention” are never two systems to reconcile. You can always show what a Playbook did, and why.
Bring your own model
Playbooks run on your own model and key. The benefit is simple: you are never locked into one provider. Use the model your business already trusts, switch when the landscape shifts, and adopt an open-weight model the moment it makes sense for you. Kibo does not force a vendor on you, and it never marks up your inference. The model is yours. The harness, the authority, and the proof are the platform’s.
The through-line
Here is the payoff. Because Kibo’s harness owns the tools, the validation, the permissions, and the record, the model becomes the swappable part. Swap one provider for another, or move to a model you host yourself, and the guarantees do not move. You are not betting on a model behaving. You are relying on a harness that holds it in place.
So write the routine down once. Kibo runs it, on your schedule or the moment something happens, under your permissions, with every run on record. Write it once, and Kibo runs it for you.
