Tempio Docs
Playbooks

Playbooks

What a playbook is

A playbook is a document Tempio keeps, written to be read by a model as much as by a person: what works on a platform, what a setting actually does, and what Tempio itself does with the thing being asked about. Each one is addressed by a slug of the form platform/topic, carries a summary, carries its sources, and carries the day a person last confirmed it.

There are two kinds and they are held to the same standard. A house note is about a part of Tempio — the draft lifecycle, the guardrails, the money rules, what a warning means — and every sentence of one is checkable against the code it cites. A platform playbook is about an ad platform, and every figure in one carries the platform's own documentation as its source.

The corpus is global. A playbook is the same document for every workspace, so nothing in it is scoped to yours and nothing in yours reaches it.

Where an agent reads one

The same text arrives four ways, from one published version:

  • As an MCP resource, so a client can attach a playbook to a conversation the way it attaches a file. Resources and prompts has the addresses.
  • As two MCP capabilities, for a client that does not implement resources: one lists the shelf, one reads a document or a single section of it. They are in the capability catalogue.
  • Inside the four prompts, which compose the relevant section of the relevant playbook into the task before the model sees it.
  • In the app: the chat is told which playbooks exist for the platforms this workspace has connected, and a media plan renders the planning section beside the items it applies to.

How one is kept current

Every playbook carries a review date, and the review date is the honest part. A document more than ninety days past its last review is served with a warning saying so, in the read itself and in the result metadata beside it, so an agent quoting the advice can quote its age with it. Nothing is hidden and nothing is quietly refreshed: a date moves when a person has actually checked the document against the platform again.

Changing one is a two-step act, for the same reason changing an ad is. A proposed edit is written as a proposal against the version it was based on; approving it publishes a new version and retires the one before it, so the shelf always has exactly one published document per slug and the whole history stays readable; rejecting it publishes nothing. Every decision is recorded with who made it and the note they left. A proposal written against a version that has since been superseded is refused rather than applied to a document its author never read.

These pages are the corpus as it stood when this release was built. A proposal approved in the console serves over MCP the moment it is approved; the page here carries it at the next release.

The shelf

Every playbook published on this shelf, what it covers, the day a person last confirmed it, and the version now serving.
PlaybookAboutLast reviewedVersion
Working on a connect-only connection
tempio/connect-only
Tempio itself. Reddit, X and Microsoft Advertising connect as accounts and raw requests. This note is how an agent reads through platform_request.get, drafts a change with a sentence, quotes a raw answer's money, and says what Tempio never verified or narrowed.2026-09-251
How Tempio makes ad stills
tempio/creative
Tempio itself. The two layers of a generated still — a copy-free scene from an image model, then copy, compliance line and logo set by Tempio's renderer from typed fields — how a preset and a compliance line are chosen and enforced, what a reference is, the scene-text check, resize against edit, the monthly allowance and a workspace's own key, and what every generation records.2026-09-231
How a change gets made in Tempio
tempio/draft-lifecycle
Tempio itself. Every write to an ad entity is a change_request row before it is a change on a platform. This note is the lifecycle — the seven statuses, who may approve, what no rule may ever approve, and what an agent should do at each step.2026-09-131
The guardrails a budget has to pass
tempio/guardrails
Tempio itself. A kill switch per connection, a daily cap derived from the account's own 28 days of spend, a movement rule, a first-budget cap and a 24-hour aggregate — checked at draft, at the approval claim and at apply. This note is what each one refuses and why.2026-09-131
What Tempio's numbers are and are not
tempio/metrics-integrity
Tempio itself. Base counts are stored and ratios are computed at read time, a zero denominator gives null rather than nought, every result states the scope it covers, and the warnings arrive before the numbers. This note is how to read a Tempio metrics answer honestly.2026-09-131
How money is written in Tempio
tempio/money
Tempio itself. Every amount is an integer number of minor units with its ISO-4217 currency beside it, never a float and never a bare number. This note is the denominations, what each platform sends on the wire, and the rule that money never crosses currencies without saying so.2026-09-131
How Tempio paces and allocates budget
tempio/pacing
Tempio itself. What a campaign was planned to spend each day, how that becomes a pace and one of five states, and how envelopes and phases become a daily set of budget moves funded under the workspace's cap. Every figure is computed at read time, nothing is stored, and every move is a change request before it is a change.2026-09-191
How to plan a flight in Tempio
tempio/planning-method
Tempio itself. A brief becomes a media plan, the plan becomes items with a whole-flight budget per platform, and materializing the plan produces one draft batch per connection. Nothing is launched — a plan makes drafts. This note is the method and the rules that refuse a plan.2026-09-131
How Tempio says what it does not know
tempio/warnings
Tempio itself. Every tool result carries a warnings array — seven classes over an open code set, three severities, and a deep-link to the record each one is about. This note is what an agent should do with each severity and each class.2026-09-131

The platform playbooks are written on a machine whose network reaches each platform's own documentation, one page per platform, and this page's status flips with the first of them.