IE Learn

The first applied AI product inside Invariant Engine, built around grounded question generation and deterministic learner state.

IMPLEMENTED AI-102 PROOF POINT / PRIVATE ALPHA

IE Learn takes prepared study material, builds a searchable evidence corpus, uses a model to generate grounded questions, and keeps scoring, weak-area analysis, readiness, review state, and persistence in application code.

It is a real AI application with ingestion, embeddings, retrieval, model generation, APIs, a learning UI, and saved learner state. It is not a general-purpose learning product yet, and the implemented study path is AI-102.

Why I built it

I wanted a useful way to study a technical subject without asking a model to invent the curriculum, grade its own work, and decide what I should trust. AI is good at turning relevant source material into a question or explanation. It is less useful as the authority for learner history, correctness, readiness, or content approval.

That led me to split the system. The model handles semantic and generative work. The application controls source lineage, question state, scoring, weak areas, study priorities, and persistence. Building that split helped shape the broader Invariant Engine architecture.

How it works

The corpus and practice workflows are connected through evidence references. A generated question carries the chunk IDs it used, and published practice content retains those references for review.

DATA 01

Prepared source material

Local Markdown, Microsoft Learn-style YAML, and transcript text that already exists.
DETERMINISTIC 02

Prepare the corpus

Normalize, hash, chunk, classify, and retain source and section metadata.
AI + DATA 03

Embed and retrieve

Ollama creates embeddings; local cosine and hybrid ranking select bounded evidence.
AI 04

Generate a grounded question

The model receives evidence text and an allow-list of chunk IDs, then returns structured JSON.
DETERMINISTIC + HUMAN 05

Validate and publish

Code checks structure, references, grounding signals, and quality. Approval and publication are explicit steps.
HUMAN 06

Practice and answer

The learner answers published questions and receives the stored explanation and evidence references.
DETERMINISTIC 07

Update learner state

IE calculates accuracy, weak objectives, readiness, and the next study priority from recorded attempts.

This is the implemented flow at a logical level. Corpus generation is a separate pipeline, and not every transition is automated.

AI has a specific job

IE Learn does not replace the model with rules. It uses model calls where probabilistic work is useful, then keeps important application decisions outside the model.

AI handles

Creating corpus and query embeddings through Ollama.
Generating structured questions from retrieved evidence.
Repairing invalid citations or weakly grounded generated output before it is checked again.
Falling back to local-model domain classification when deterministic rules have low confidence.

Deterministic code handles

Normalization, hashing, chunking, provenance, and retrieval ranking.
Question structure, citation allow-lists, quality checks, and lifecycle rules.
Correctness, objective accuracy, weak areas, difficulty thresholds, and readiness.
Practice eligibility, explicit approval/publication states, session state, and persistence.

The original adaptive loop chooses the lowest-mastery domain deterministically. The newer question-bank workflow identifies weak objectives deterministically, then samples and shuffles eligible published questions. I do not describe the exact next question as deterministic in every path.

System architecture

The implementation is a modular .NET solution. These are code and responsibility boundaries, not a claim that IE Learn runs as a set of independently deployed microservices.

Knowledge pipeline

Local source discovery, prepared transcript cleanup, normalization, stable hashing, semantic Markdown chunking, classification, and JSONL export.

Embedding and retrieval

Ollama embeddings, JSONL datasets loaded into memory, query embeddings, cosine similarity, domain and authority signals, and bounded context results.

Model boundary

The active Learning configuration uses a local Ollama question generator. An Azure OpenAI structured-output implementation also exists, but it is not the current registered generator.

Application and APIs

ASP.NET Core and MediatR handlers expose generation, review, question-bank, practice, readiness, dashboard, evidence, and learner-context operations.

Learning model

Domain models and handlers own questions, options, evidence, attempts, sessions, weak-area rules, study recommendations, timed metrics, and readiness.

State and UI

Configurable EF repositories support SQLite or SQL Server, with in-memory fallbacks. Blazor surfaces cover practice, dashboards, history, blind review, and evidence review.

What IE Learn proved

An end-to-end AI data path

Source preparation, chunking, embeddings, local vector retrieval, bounded context, and grounded question generation exist in one applied workflow.

Models can stay inside a boundary

The model proposes question content. Deterministic checks and explicit state transitions decide whether that content is eligible for practice.

Adaptive state does not need model guesses

Attempts, accuracy, weak objectives, recommendations, timed performance, and readiness are calculated from recorded state.

AI workflows can survive reload

EF integration tests recreate database contexts and verify question, evidence, attempt, session, lifecycle, and batch-run state after reload.

Those tests establish implemented behavior and state continuity. They do not prove model output is correct, predict an exam result, or make the private alpha production ready.

How it relates to Invariant Engine

IE Learn came first as the concrete application. The initial learning loop and knowledge pipeline predate much of the current general-purpose framework.

It exposed the architectural problem. Context needed a known source, generated content needed checks and review states, and learner decisions needed to remain outside the model.

Invariant Engine generalizes those lessons. The current platform applies the same separation to engineering evidence, model reasoning, validation, human decisions, execution, and approved memory.

Study scope

I built the implemented workflow around AI-102 material. It gives me a practical way to organize source material, generate reviewed practice content, find weak objectives, and focus the next study session. The readiness result describes performance inside IE Learn; it is not a prediction or guarantee of an exam result.

Current boundaries

IE Learn reads local source material and prepared transcript text. It does not crawl GitHub or ingest arbitrary URLs.
It does not transcribe audio or video, and Whisper is not integrated.
Retrieval uses local JSONL embedding datasets loaded into memory, not a managed vector database.
Generated questions require explicit lifecycle transitions before publication; the model does not silently approve its own output.
The implemented product focus is AI-102, not universal certification support.
IE Learn remains part of a private alpha and is not generally production ready.