Evidence frozen at capture
What they knew at the time — value, source definition, freshness, and provenance snapshotted the moment evidence informs a decision. Not a screenshot, not a stale export.
Loading
Governed Decision Intelligence
AI now participates in operational decisions. “The model said it was fine” is not an answer an auditor will accept.
Your ERP records what happened. Boss Loops governs what happens next.
Boss Loops turns every consequential operational decision into a governed, auditable record — fusing the evidence, the policy, the people, and the AI that produced it, and proving, years later, why the decision was made.
Supplier invoice approvals. Purchase approvals. Inventory exceptions. Returns triage. Credit reviews. The decisions your operation makes every day — with the approvals, the exceptions, and the “prove why we approved it” that comes months later.
When the auditor asks why it was approved, you don't reconstruct the story. You retrieve it.
The Decision Record
Decisions deserve a system of record
One record holds the situation, the evidence — frozen at the moment it was used, from governed sources, not a link that may have changed since — the policies that applied, the people and AI that participated, the outcome that followed, and the learning it produced. GRC holds policy. BI holds metrics. Workflow holds steps. Chat holds the AI's reasoning until the window closes. None of them holds all of it, linked, as one auditable artifact.
In Boss Loops this isn't a convention a well-behaved workflow follows — it's enforced by the engine. A consequential decision cannot commit without frozen evidence, recorded provenance, and an approval bound to the exact evidence the approver saw. Immutable, hashable, replayable — by construction, not by discipline.
Approvals bound to evidence
The authorized approver signs under their own name, against the exact evidence they saw. Human, automation, and AI actors share one attribution model.
Answerable years later
Who decided, on what evidence, under which policy, and whether it worked — retrieved as a record, not reconstructed across four systems.
What it looks like in practice
A refrigerated shipment records a temperature excursion in transit. Instead of an alert someone has to chase, it opens a decision: lot release review. Boss Loops attaches governed evidence automatically — the peak excursion from the validated monitoring system, the batch's stability data, the release criteria from the current SOP — each frozen with its source and timestamp. Policy checks the reading against the criteria. Quality reviews; the authorized approver signs off against the exact evidence they saw. A year later, when someone asks why the lot was released, the answer isn't a scramble across four systems. It's a record.
This is a pattern, not a vertical. The same record that defends a lot release defends a capital authorization, a credit approval, a sole-source supplier commitment, or a claims adjudication.
Supplier invoice approvalPurchase approvalInventory exceptionsReturns triageCustomer credit review
Architecture
Governed decision runtime
Boss Loops is the operational substrate where AI-assisted work becomes accountable. Intelligence proposes; loops and guards decide whether a transition may commit; channels carry human oversight; integrations execute only after policy passes. Evidence is recorded at the moment of the decision — not rebuilt from logs later.
Canonical runtime flow
Providers
Loops + Guards
Channels
Integrations
Evidence + Learning
Providers never bypass governance. Integrations do not call models directly without a governed loop transition. Durable workflow engines may execute approved work — loops govern whether that work is allowed.
Runtime layers
Model Providers
Intelligence systems — analyze, recommend, classify. They do not write to CRM or approve in Slack.
Evidence Providers
Governed evidence — Snowflake semantic views, Looker metrics, Samsara readings — frozen onto the Decision Record with qualification inherited from the source.
Channels
Human coordination — Slack, Teams, email, doc comments. Not systems of record.
Integrations
Operational execution — Salesforce, Jira, Sheets apply, APIs. Not governance.
Governance
Guards
Deterministic policy at runtime — enforce rules, constrain execution, require evidence.
Evidence
Structured context on every transition for audit and operational learning.
Human oversight
Human actors use the same attribution and guard model as automation and AI agents.
Workflows vs Boss Loops
Workflows define the path. Temporal, n8n, and application orchestration coordinate durable steps.
Boss Loops governs the transitions. Boss Loops decides who may move state, under which guards, with what evidence — before side effects land in your systems.
Boss Loops vs workflow engines →Evidence Providers
Consume the semantics you already govern
Your warehouse and BI investments already define what the numbers mean. Boss Loops attaches that definition to the Decision Record — frozen at capture, with qualification inherited from the source, never asserted by the loop. No re-modeling your business to get there.
- PreviewLooker semantic evidence on the Alpine golden record
- PlannedSnowflake governed semantic views
- PlannedSamsara operational readings at decision time
Open core · Apache-2.0
Governance you can verify, not take on faith
Anyone can say “governed.” The Boss Loops engine, the evidence contracts, and the conformance suite are open — inspect them, self-host them, and prove the invariants yourself. The invariants hold in the open engine, not behind a paywall: a consequential decision cannot commit without frozen evidence, recorded provenance, and an approval bound to what the approver saw.
Because the conformance suite is an executable artifact, “every evidence source in this decision conformed to the contract” is a statement an auditor can verify — not a marketing claim. What the hosted tier adds isn't the governance. It's production Evidence Providers, curated policy packs, and the Decision Operations workspace.
Apache-2.0 with explicit patent grant — fully permissive, OSI-approved, patent-safe.
Used with Commerce Gateway
Governance sits on execution — not beside it
Boss Loops governs actions that are executed through Commerce Gateway. It is a control layer for policy, guards, and audit — not a standalone automation tool that replaces your gateway or operators.
Commerce Agent pattern (illustrative — a composition, not a separate product):
Agent → Registry (discover) → Gateway (execute) → Boss Loops (govern) → Recorded outcome
Related from Better Data
Architecture notes and rollout updates
Boss Loops is Apache-2.0 open operational infrastructure with a first-class path on Better Data. Cross-module architecture updates, hosted path guidance, and launch context are published on the Better Data blog.
Runtime connections
Three layers, one governance runtime
Model Providers generate intelligence. Evidence Providers attach governed evidence. Channels coordinate humans. Integrations execute against systems of record. They are not interchangeable — Boss Loops governs transitions between them with guards and evidence.
- Channels are not integrations.
- Providers are not workflow systems.
- Integrations are not governance.
- Boss Loops sits between all three and governs transitions.
Intelligence systems
Providers
Generate analysis and recommendations — they do not commit operational state.
Typical actions
Analyze · Recommend · Classify · Predict · Draft
Examples
OpenAI, Anthropic, Gemini, Perplexity Sonar
Providers are not workflow engines, channels, or systems of record.
Human coordination surfaces
Channels
Coordinate people — request approvals, surface decisions, escalate operators.
Typical actions
Notify · Approve · Reject · Escalate · Comment
Examples
Slack, Microsoft Teams, Email, Docs comments, OpenClaw routing
Channels are not integrations — humans decide here; systems execute elsewhere.
Systems of record
Integrations
Execute operational actions and persist business state after governance passes.
Typical actions
Persist · Trigger · Update · Apply · Sync
Examples
Salesforce, PagerDuty, Jira, Google Workspace, HTTP APIs, Postgres
Integrations are not governance and not human coordination.
Featured adapters & patterns
npm adapters wire each layer into createLoopSystem. Boss Loops is not a generic integration platform or Slack bot.
Apache-2.0 with explicit patent grant — the only governed execution layer in this space with a fully permissive, OSI-approved, patent-safe license. Temporal and Inngest ship under SSPL.
Perplexity + PagerDuty
Sonar grounds research with citations; Boss Loops runs the governed incident FSM; PagerDuty delivers human review and escalation. End-to-end audit trail on every step.
- ·Research steps use Sonar with domain filters and required citations
- ·Risk classification and human gates before any PagerDuty trigger
- ·Custom details on incidents include audit references for compliance review
OpenClaw
OpenClaw is the agent that acts. Boss Loops is the runtime that governs what it's allowed to do.
- ·Wrap OpenClaw skills with hard approval gates - structural, not prompt-based
- ·Route PENDING_HUMAN_APPROVAL events to WhatsApp, Telegram, Slack, or Discord
Vercel AI SDK
Wrap any Vercel AI SDK tool call with structural approval gates and audit trails. Drop-in compatible with useChat and streamText.
- ·requiresApproval() gate - structural, not prompt-based, cannot be injected away
- ·Full transition audit trail on every tool call, pass or approve
PagerDuty
AI agent actions page your on-call engineer. No new approval UI - your team already lives in PagerDuty.
- ·PENDING_HUMAN_APPROVAL triggers a PagerDuty incident with full loop context and approval link
- ·Incident auto-resolves when the loop is approved or rejected
Claude
AI actor decisions with full governance — confidence scoring, prompt attribution, and hard guard enforcement at the runtime level.
- ·Confidence guard blocks low-certainty transitions - structural, not prompt-based
- ·Prompt hash recorded on every AIAgentActor for audit trail
- ·Human-only guard enforces approval boundary regardless of model instructions
OpenAI
Same governance model for GPT-4o and o-series — identical guard enforcement, same audit trail, drop-in alongside Claude in multi-model loops.
- ·Structured JSON response parsing via response_format built in
- ·provider field distinguishes Claude vs GPT-4o in the audit trail
- ·Works alongside adapter-anthropic in the same loop definition
Grok
Governed AI actors via xAI's Grok API — OpenAI-compatible format, same guard enforcement as other adapters.
- ·OpenAI-compatible API - drop-in with adapter-openai pattern
- ·Grok 3 and Grok 3 Mini supported
- ·provider: "grok" field distinguishes in audit trail
Gemini
Google Gemini as a governed Boss Loops actor — native Google AI SDK, Gemini 1.5 Pro and 2.0 Flash supported.
- ·Native @google/generative-ai SDK (not OpenAI-compatible)
- ·Automatic JSON code fence stripping - handles Gemini quirks
- ·Gemini 1.5 Pro, Flash, and 2.0 Flash supported
Perplexity Sonar
Grounded web retrieval with cited sources for decision loop steps that need verifiable, real-time information — regulatory lookups, supplier news, compliance research.
- ·Citations are first-class output for audit and evidence attachments
- ·Domain filters and recency filters map directly to Sonar API parameters
- ·Implements guardEvidence to mask pplx-* keys in logged payloads
n8n
Approval gates and operational evidence layered onto n8n automations.
Temporal
Governance and decision control layered onto Temporal execution — policy gates and evidence around long-running workflows.
Quick start
Running in 60 seconds
- 1. Install the SDK
- 2. Define your loop
- 3. Start and transition
- 4. Subscribe to events
import { parseLoopYaml, validateLoopDefinition } from '@loop-engine/sdk'
const yaml = `
loopId: expense.approval
version: 1.0.0
name: Expense Approval
description: Human approval for submitted expenses
initialState: SUBMITTED
states:
- stateId: SUBMITTED
label: Submitted
- stateId: APPROVED
label: Approved
terminal: true
- stateId: REJECTED
label: Rejected
terminal: true
transitions:
- transitionId: approve
from: SUBMITTED
to: APPROVED
signal: approve
allowedActors: [human]
- transitionId: reject
from: SUBMITTED
to: REJECTED
signal: reject
allowedActors: [human]
`
const definition = parseLoopYaml(yaml)
const checked = validateLoopDefinition(definition)
if (!checked.valid) {
throw new Error(checked.errors.map((e) => e.message).join('; '))
}Everything you need to build on
@loop-engine/sdk
High-level entry point for loop systems.
@loop-engine/core
Canonical types and model contracts.
@loop-engine/runtime
Loop engine execution lifecycle.
@loop-engine/dsl
YAML and builder loop definition APIs.
@loop-engine/events
Event contracts and event bus types.
@loop-engine/guards
Built-in and custom guard registry.
@loop-engine/actors
Actor model and attribution helpers.
@loop-engine/observability
Metrics, timelines, replay.