Loop Engine model
Signal
Loop Engine
Actor
Transition
Evidence
Learning
Loading
Open Infrastructure · Apache-2.0
Without governance, AI agents improvise — no approval gates, no audit trail, no accountability.
The control layer for AI-operated enterprises
Loop Engine gives AI finite states, deterministic guards, and structured feedback. Not improvisation - control.
A Loop is a named finite state machine — with typed actors, guard policies, and an immutable evidence trail on every transition.
Install only what you govern.
SIGNAL
LOOP ENGINE
ACTOR
TRANSITION
EVIDENCE
LEARNING
System context
How Loop Engine fits into real systems
Most enterprise AI projects hit the same wall: a capable model, a data source it's not allowed to touch directly, and no structure for what happens between a signal and a recorded outcome. Loop Engine is the layer that sits in that gap.
Loop Engine is the execution and control layer inside a larger operational stack. It does not replace your data warehouse, ERP, or application UI. It sits where decisions become actions, enforces bounded transitions, and records evidence on every state change.
In practice: signals detect change, decision logic selects next action, Loop Engine executes inside explicit guardrails, evidence is captured for each transition, and the resulting feedback improves future decisions. This pattern is used in production systems, including the Better Data platform.
Better Data system model
Sense
Decide
Execute
Govern
Improve
Loop Engine anchors the execution boundary while preserving full transition evidence.
Used with Commerce Gateway
Governance sits on execution — not beside it
Loop Engine 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) → Loop Engine (govern) → Recorded outcome
Related from Better Data
Architecture notes and rollout updates
Loop Engine stays standalone and OSS-first. Cross-module architecture updates, hosted path guidance, and launch context are published on the Better Data blog.
Structure, not improvisation
AI works best when decisions are bounded, outcomes are measurable, and every action leaves evidence. Loop Engine provides that structure.
Every actor accounted for
Human, automation, AI agent - the actor model treats all three identically. No action is anonymous. Every transition has attributed evidence.
Loops learn
Each closed loop emits structured training signals. Forecasts improve. Lead times sharpen. The system gets better automatically.
Integrations
Integrations across the agentic ecosystem
Adapters plug into the control layer — Loop Engine is not a generic “do anything” automation runner. Pair with Commerce Gateway when commerce execution needs the same guardrails.
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; Loop Engine 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. Loop Engine 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 Loop Engine 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 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
Stateful approval checkpoints and auditable loop orchestration for n8n automations.
Temporal
Loop Engine governance hooks for long-running Temporal workflows and human gates.
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.