InvariantEngine
Invariant Engine is an AI systems architecture I'm building to make AI-assisted engineering easier to trust, review, and operate. The model is a reasoning component, not the source of truth.
Private alpha · IE-on-IE MVP Batches 1–5 implemented
IE has model-gateway, local Ollama, reasoning-session, and streaming foundations. The current Guided Mode demo focuses on the controls around AI-assisted engineering and uses a manual Codex handoff rather than live model review. IE Learn is the first applied AI product in the repository: it uses embeddings, retrieval, and grounded question generation while deterministic code owns learner state and review rules.
Why I built it
I wanted AI to help with serious engineering work without hiding the context, evidence, or decisions behind a generated answer. A model can reason over a problem, but it should not decide what the project accepts as true or move work into execution on its own.
IE is the system around that reasoning step. It controls the context a model receives, preserves where the evidence came from, validates the shape of the work, requires explicit human decisions, and keeps suggested learning pending until someone approves it.
The system around the model
The model is one component in this architecture. It can propose an explanation, plan, or implementation, but evidence, policy checks, human review, execution, and approved project memory remain separate concerns.
See the architecture and current boundaries →Why deterministic controls exist
IE is not an attempt to replace AI reasoning with a rules engine. The deterministic parts surround probabilistic reasoning with controls that can be tested independently.
Establish known facts
Source hashes, compiler inventory, approved memory, and recorded workflow state give the system facts it can check.
Bound model context
Context preparation controls which evidence and project decisions are available to a reasoning session or handoff.
Validate structure and references
Independent checks catch missing links, stale evidence, policy failures, and incomplete workflow state.
Protect state changes
Model output stays proposal material. Human gates control planning acceptance, execution review, and approved memory.
The framework and its first applied product
Invariant Engine
The framework separates evidence, prepared context, model reasoning, deterministic checks, human decisions, execution, and approved state.
IE Learn
The first applied product uses that separation for an AI-102 learning system with ingestion, chunking, embeddings, retrieval, grounded question generation, review, practice, and persistent learner state.
IE Learn began as the concrete application and helped shape the larger architecture. The model generates grounded question content; it does not calculate weak areas, readiness, or decide what gets published.
See the implemented IE Learn architecture ->What works today
Evidence with a known origin
IE keeps scoped repository snapshots, hashes, compiler inventory, and provenance attached to the work that uses them.
Prepared context
Context Packs assemble approved memory, source evidence, workflow state, risks, and the next action without making an LLM call.
Independent checks
Deterministic diagnosis, quality, drift, reference, closure, and restart checks can be run without trusting model output.
Human decisions at state changes
The operator confirms scope, accepts planning, reviews results, and separately decides whether suggested learning becomes project memory.
Manual AI implementation handoff
IE prepares a scoped task packet for Codex and analyzes the pasted report. The current demo does not call Codex or execute the work autonomously.
Feedback and controlled learning
Reviewed outcomes, validation evidence, pending memory suggestions, approval decisions, and their original references stay connected.
The current Guided Mode workflow
1. Ground and diagnose
A human confirms source scope. IE captures evidence and runs a deterministic current-state diagnosis.
2. Choose and plan
A human chooses one improvement and separately reviews the planning records before work advances.
3. Hand off to Codex
IE prepares a task packet. The operator manually copies it into Codex and pastes the final report back.
4. Validate, review, and learn
IE checks the pasted report; a human reviews the outcome, records feedback, and separately decides on pending memory.
Limits and trust boundaries
- Output from models, including Codex, is proposal material, not verified truth.
- Guided Mode does not currently expose a live governed LLM review; its demonstrated Codex loop is manual and paste-driven.
- Invariant Engine does not autonomously edit source code.
- Invariant Engine does not autonomously create pull requests.
- There is no Codex API integration or autonomous implementation execution in the demonstrated workflow.
- Evidence and deterministic checks support review but do not prove correctness.
- Memory suggestions remain pending until a human separately approves or rejects them.
- Restart verification proves continuity of saved state, not source correctness, model-output truth, or production readiness.
- Human approval remains the truth gate.
- The source repository remains private.
Current status
Private alpha · MVP rebaseline July 29, 2026 · Guided Mode updated July 30, 2026
Batches 1–4 cover scoped onboarding, diagnosis, planning history, the manual Codex loop, result review, feedback, memory disposition, and restart verification. Batch 5 adds the repeatability runbook, clean-checkout rehearsal, and sanitized review package; it does not add Engine capability.
The full workflow has survived a real API/client restart against configured durable state. That proves the saved records can be reconstructed. It does not prove source correctness, make model output true, or make the private alpha generally production ready.
The source repository remains private. This marketing site is the only planned public artifact at this stage.
Read the current limitations →