ES

A typed, event-driven constraint protocol for AI-generated systems.

RIGOR

Core Semantic Version v0.1 — Frozen and Normative

RIGOR Core v0.1 defines the formal semantics of the language and is now frozen. This guarantees determinism, structural consistency, and long-term compatibility for future implementations.

RIGOR is a formal specification language designed to constrain, validate and govern AI-generated backend systems.

It defines explicit state transitions, typed context mutation rules, and deterministic execution boundaries.

Access Specification →
02

Why RIGOR?

Modern software increasingly relies on AI-assisted generation. Narrative prompts are expressive but ambiguous. As systems grow in complexity, ambiguity increases, drift becomes inevitable, and regeneration becomes unpredictable.

RIGOR exists to introduce structure where narrative fails. It is not a framework or an engine—it is a formal protocol designed to make AI-assisted system generation reliable.

  • Deterministic execution semantics
  • Explicit state mutation boundaries
  • Typed context validation
  • Replayable event processing
  • Specification-level invariants

RIGOR turns architectural intent into a verifiable contract.

02

What is RIGOR?

RIGOR is an open specification that defines how AI-generated systems must behave.

  • Explicit state machines
  • Typed context schemas
  • Event-driven transitions
  • Deterministic mutation rules
  • Validation before execution

RIGOR separates specification from implementation. The specification defines what is allowed. Implementations execute under those constraints.

04

Deterministic Event-Driven Mutation

In RIGOR, state cannot be modified arbitrarily. All mutations must occur inside explicitly declared transitions triggered by events. No state change is allowed outside the transition model.

This guarantees deterministic execution, traceable behavior, predictable regeneration, and strong consistency boundaries.

04

Structural Acceleration

AI-native systems increase implementation velocity beyond human structural oversight capacity.

Generation throughput now exceeds structural validation throughput.

When structural change outpaces structural governance, systems accumulate implicit transitions, undeclared evolution, migration ambiguity, and contract instability.

This condition produces structural entropy.

05

Structural Entropy

Structural Entropy is the progressive increase of implicit, unclassified, or non-deterministic structural behavior across iterative system evolution.

Structural entropy manifests when:

  • Transitions are inferred instead of declared.
  • Version changes are untyped.
  • Migrations alter behavior without formal classification.
  • Execution diverges from documented intent.

Structural entropy is cumulative. Without constraint, it becomes irreversible.

RIGOR positions itself as an entropy-reduction protocol.

06

Core Invariants

The following properties are non-negotiable across all RIGOR-compliant systems:

01

Explicitness

No implicit mutations. No hidden state changes. All context mutations must be declared within event transitions.

02

Determinism

For a given state and event, the resulting transition is uniquely defined. The pair (state, event) must be unambiguous.

03

Classified Evolution

All structural changes must be typed as compatible, conditional, or breaking. Silent evolution is invalid.

04

Validation Before Execution

Structural validation is a precondition of existence. Execution without validation violates the protocol.

05

Controlled Mutation

Context can only mutate inside transitions triggered by declared events. Each event is processed as an independent transactional unit.

06

Specification / Implementation Separation

RIGOR defines a protocol. Engines implement it. The language is independent of any runtime.

07

Stable Core, Classified Evolution

RIGOR Core v0.1 defines the minimal invariant semantics of the protocol. Core invariants are frozen and versioned. Future evolution follows a classified model (Patch, Minor, Major) to ensure safe long-term adoption.

08

Typed Context & Schema Validation

RIGOR specifications define an explicit and typed context schema. Every process declares the structure of its persistent state, allowed data types, and required fields. RIGOR eliminates runtime ambiguity by enforcing compile-time structural validation.

09

AI Constraint Protocol Model

The protocol comprises five normative components:

  • 01
    Intent Domain — Defines the formally allowed structural space.
  • 02
    Constraint Contract — Machine-verifiable specification instance.
  • 03
    Generation Boundary — Interface between AI output and validation.
  • 04
    Validation Engine — Evaluates structural compliance.
  • 05
    Evolution Layer — Classifies all structural changes.
10

Backend-First Strategy

RIGOR begins as a backend-focused specification language.

  • Process orchestration
  • Domain state machines
  • External service invocation boundaries
  • API contract governance

Frontend and contract derivations may emerge from the backend specification layer.

11

Transactional Execution Model

Every event processed by a RIGOR Engine is handled in isolation, produces at most one state transition, and persists its effects atomically. Failure during processing results in no partial state mutation or ambiguous intermediate states.

12

Specification First. Engine Second.

RIGOR is a specification, not an engine.

  • The Core defines the semantics.
  • Any compliant engine may implement execution.
  • The official reference engine will serve as a normative implementation, but the language remains implementation-independent.
10

Structural Positioning

RIGOR operates upstream of execution. It does not orchestrate. It does not execute. It constrains structural possibility.

System What It Does RIGOR Does
Workflow Orchestration (Temporal, AWS Step Functions) Manage distributed execution. Coordinate runtime behavior. Handle retries and state persistence. Define what processes are structurally allowed to exist before execution.
Infrastructure as Code (Terraform) Define infrastructure state declaratively. Define structural process evolution constraints.
Static Analysis (Type Systems, Linters) Validate code correctness. Enforce compile-time constraints. Classify structural evolution across versions. Govern AI-generated structural possibility space.
Domain-Specific Languages Encode process definitions in syntax. Define structural invariants independent of implementation language.

RIGOR is upstream of orchestration. It defines the structural boundary between generation and execution.

14

Conceptual Territory

RIGOR owns the conceptual space of:

  • 01 Pre-Execution Structural Protocol
  • 02 AI Structural Boundedness
  • 03 Deterministic Evolution Governance
  • 04 Version-Typed Process Contracts
  • 05 Structural Entropy Reduction

This territory is not formally occupied by existing platforms.

15

Protocol vs Prompt Engineering

Aspect Prompt Engineering AI Constraint Protocol
Approach Descriptive Prescriptive
Method Persuades model Defines boundaries
Control Relies on phrasing Formalizes domain
Validation Probabilistic variance Structural containment
Output Approximate intent Bounded execution

Prompt engineering attempts to guide probabilistic behavior. AI Constraint Protocol constrains structural possibility.

16

Project Status

  • RIGOR Core v0.1 — Formal Specification Complete
  • Specification Documents — Public
  • Validator CLI — In development
  • Reference Engine (MVP) — Planned
  • Community Governance — Target Phase

RIGOR aims to become an open, implementable standard for deterministic AI-constrained systems.

17

Contribute on GitHub

Help refine the specification. Build compatible engines. Participate in future governance.

Access Specification → View on GitHub →