Running Temper

For someone standing up a deployment and keeping it healthy — your own instance, your own
identity provider, your own data.

What the architecture fixes versus what your deployment chooses is set out at
temperkb.io/operating. These pages are the runbooks.

Standing it up

Self-hosting Temper — the operator runbook: the
Vercel project, the database, the environment.

Bootstrapping an org — turning a fresh deployment
into one with people in it.

For a larger installation, Enterprise install covers
the same ground with the decisions an enterprise has to make called out. It is an annotated
variant of the self-hosting runbook, not a separate path.

Identity

Pick the one that matches your IdP:

Okta

A SAML IdP — the generic SAML path.

The trust boundary these configure — how a credential becomes a session, and where that is
enforced — is described in The Trust Boundary. The
auth-identity contract — whose tokens this instance trusts and which it accepts — is in
Auth identity.

When someone leaves

Offboarding a departure — ending a departing
person's admission, handing off the work they owned, and the bound to quote when nobody
acts. Includes why the revoke, and not an IdP-side group removal, is the acting control.

Erasure and the terms of use — the destructive
compliance act that sits outside the departure runbook: what an erasure wipes (including
guests' content in the subject's own contexts), what stays in shared contexts, and what the
record only reports.

Keeping the corpus under the blocking policy

Reblocking a corpus — bringing existing resources under
the current blocking policy in bounded, verified batches: the survey → act → re-survey loop,
reading the receipt, and validating each batch against the ledger.

Connecting the rest of your world

Slack mentions — end-to-end setup.

Slack identity and revocation — what the
integration actually does: identity, credentials, and what is retained.

GitHub connection — provisioning a read-only GitHub
App and wiring it to Temper in both directions: the brokered token agents read GitHub with,
and the webhook path GitHub's events arrive on.

Agents that run on your deployment

Deploying a steward agent — fork-first
deployment to your own Vercel project.

Delivering L0 kernel content — fork-first delivery
of the L0 kernel cogmap.

Bootstrapping a team's self-cognition map
— standing up the team map the steward agents author into.

Seeing what it is doing

Sending traces to an OTLP backend —
getting traces and metrics out.

Telemetry — what Temper emits, the OTLP export model, and
what the architecture fixes vs. what the deployment configures.

Query cost and the bounds that shape it — the four
bound layers, why a bound on waiting is not a bound on work, and how to measure before choosing
an execution budget.

Compose queries that stay fast — the
operator knobs in order of leverage, and the four numbers worth checking.

Rate-limit an instance at the edge — measuring
your own traffic, database cost and capacity, and turning them into firewall rules that start
in log mode.

Verifying releases

Release verification — how to verify a Temper
binary: manifest, signature, and attestation.

Every setting

The configuration reference documents every field of
config.toml — type, default, and what it does — rendered from the config type itself.

Running Temper

Standing it up#

Identity#

When someone leaves#

Keeping the corpus under the blocking policy#

Connecting the rest of your world#

Agents that run on your deployment#

Seeing what it is doing#

Verifying releases#

Every setting#