Apache-2.0 governed runtime — self-host with @loop-engine/sdk or adopt Loop Engine Cloud on Better Data.
See Commerce Chain Optimization →Loading
Open Infrastructure · Apache-2.0
Without governance, AI agents improvise — no approval gates, no audit trail, no accountability.
Loop Engine connects AI providers, communication channels, and enterprise systems through decision loops.
AI operates inside deterministic governance boundaries — guards enforce policy, actors are attributed, and evidence is captured on every transition. Decision loops are the unit of work; finite states are the runtime mechanism.
Install only what you govern.
Run standalone on any stack, or compose with Loop Engine Cloud and Commerce Chain modules on Better Data.
Runtime platform
Loop Engine 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 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.
Providers
Intelligence systems — analyze, recommend, classify. They do not write to CRM or approve in Slack.
Channels
Human coordination — Slack, Teams, email, doc comments. Not systems of record.
Integrations
Operational execution — Salesforce, Jira, Sheets apply, APIs. Not 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 loops
Workflows define the path. Temporal, n8n, and application orchestration coordinate durable steps.
Loops govern the transitions. Loop Engine decides who may move state, under which guards, with what evidence — before side effects land in your systems.
Loop Engine vs workflow engines →System context
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.
Governed runtime path
Better Data system model
Loop Engine anchors the execution boundary while preserving full transition evidence.
Used with Commerce Gateway
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
Loop Engine 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.
Hard and soft guards run in the runtime — not in prompts. Transitions that fail policy do not advance; denials are recorded for audit.
Structured evidence explains why a decision was allowed — inputs, confidence, approvals, and citations where applicable.
Human, automation, and AI agent actors share one model. Channels deliver approval gates; integrations execute only after governance passes.
Runtime connections
Providers generate intelligence. Channels coordinate humans. Integrations execute against systems of record. They are not interchangeable — Loop Engine governs transitions between them with guards and evidence.
Intelligence systems
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
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
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. Loop Engine 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.
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.
OpenClaw is the agent that acts. Loop Engine is the runtime that governs what it's allowed to do.
Wrap any Vercel AI SDK tool call with structural approval gates and audit trails. Drop-in compatible with useChat and streamText.
AI agent actions page your on-call engineer. No new approval UI - your team already lives in PagerDuty.
AI actor decisions with full governance — confidence scoring, prompt attribution, and hard guard enforcement at the runtime level.
Same governance model for GPT-4o and o-series — identical guard enforcement, same audit trail, drop-in alongside Claude in multi-model loops.
Governed AI actors via xAI's Grok API — OpenAI-compatible format, same guard enforcement as other adapters.
Google Gemini as a governed Loop Engine actor — native Google AI SDK, Gemini 1.5 Pro and 2.0 Flash supported.
Grounded web retrieval with cited sources for Loop steps that need verifiable, real-time information — regulatory lookups, supplier news, compliance research.
Approval gates and operational evidence layered onto n8n automations.
Governance and decision control layered onto Temporal execution — policy gates and evidence around long-running workflows.
Quick start
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('; '))
}@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.