CRSIS—Continuous Runtime Self-Improvement System—is what turns Herald from a clever architecture into something that doesn't exist yet. But CRSIS doesn't operate in a vacuum. It sits on top of Concept D's cognitive architecture: a persistent world-state model, specialist workers, and an evidence-grounded judge. The world model provides the foundation. CRSIS provides the self-improvement loop that runs on top of it.
Why this is genuinely dangerous—and why it works anyway
Let's be direct: an AI system that can rewrite its own decision-making logic is the plot of every cautionary AI film ever made. The reason those scenarios are terrifying is that the AI operates as a black box—nobody can see what changed or why. Skeptic's brain is not a black box. It's deterministic Python code with a world-state model that tracks every belief separately from every piece of evidence. Every change is a git diff. Every proposal shows exactly what line changes, what evidence triggered it, and what rollback looks like. The danger isn't self-improvement. The danger is self-improvement without transparency. Skeptic has transparency by architecture.
Before the system can improve itself, it needs to understand the world it operates in. Concept D provides four components that turn Esoteric v0.2 from a turn-by-turn chatbot into a system that maintains a live internal model of reality.
State Builder
Processes each event and updates the world-state model. Deterministic transitions. No LLM involved in state management. Every state change is diffable and testable.
Planner
Reads the structured world-state and produces action plans. Code reading data and applying priority rules, not a model reasoning about 'what should I do next?'
Specialist Workers
Code (deepcoder:14b), Logic (rnj-1:8b), Code Reviewer (deepseek-r1:8b), Vision (qwen3-vl:8b), Research (gemma4:12b), Memory, Web, Desktop. Ten seats across eight models. Each worker has one domain. Workers produce evidence, not opinions.
Judge / Verifier
Checks outputs against grounded evidence: tool output, file reads, OCR results, memory provenance. Evaluates proof, not plausibility. The last gate before output.
No matter which models are used, these four rules are enforced architecturally—not by prompting. The system cannot bypass them because they are built into the Judge and the output assembly pipeline.
1
Tag Every Claim
Every internal claim is tagged: observed (tool output), recalled (memory), inferred (reasoning), or guessed (low confidence). No untagged claims reach the output.
2
Prefer Observed
Final output prefers observed > recalled > inferred > guessed. The evidence hierarchy is structural, not prompt-based. Architecture enforces what prompts cannot.
3
Evidence Resolves Conflict
When two sources disagree, the source with higher evidence provenance wins. Not the prettier answer. Not the more confident model. The one with proof.
4
Separate Belief and Evidence
Two stores: what it believes (inference, hunches, defaults) and what it can prove (tool outputs, file reads, OCR results). They are never merged blindly.
Concept D provides the cognitive architecture—the world-state model, the evidence store, the judge. CRSIS provides the self-improvement loop that runs on top of it. Below is how the system learns from its own performance.
1
Observe
Every turn logs its routing decision, tool selection, renderer output, and implicit user satisfaction signals. Did the user re-ask the same question? Say "that's wrong"? Or accept and move on?
2
Analyze
Pattern detection runs on the decision log. Which intents are misrouted? Which tool results are empty? Which renderer outputs get corrected by follow-up messages?
3
Propose
The system generates concrete improvement proposals: new exact-match phrases, adjusted classification thresholds, additional synonym mappings, new tool registrations, new memory retention rules.
4
Gate
No change applies without human approval. Every proposal shows what it changes, why, what evidence triggered it, and a rollback path. The system cannot modify itself silently.
5
Apply & Validate
Approved changes are applied atomically with a snapshot taken first. If the test suite fails or the system degrades, automatic rollback restores the previous state. The loop restarts.
It Writes Its Own Brain
CRSIS doesn't tune model weights or adjust prompts. It modifies the deterministic code that makes every routing, tool selection, and classification decision. It's rewriting the logic that controls the entire system.
Compounding Intelligence
Each improvement cycle makes the next one more effective. Better routing produces cleaner logs. Cleaner logs produce better analysis. Better analysis produces smarter proposals. The system accelerates its own improvement rate.
The Terminator Problem
An AI that can rewrite its own decision-making code is the premise of every runaway AI scenario. Ultron. Skynet. The difference is the gate: CRSIS cannot apply changes without explicit human approval. Remove the gate, and you have an autonomous system that rewrites its own brain. That's why the gate is not optional. It's architectural.
Why This Hasn't Been Done
Every other AI system puts the LLM in the decision loop. You can't safely let a black box modify itself because you can't predict, audit, or reverse the changes. Herald's brain is deterministic code. Code can be diffed, tested, versioned, and rolled back. That's what makes self-improvement tractable instead of catastrophic.
The world model is the foundation. The evidence store is the source of truth. The judge is the gatekeeper. CRSIS is what makes it dangerous. The human gate is what makes it controllable. Remove the gate and you have Ultron. Keep the gate and you have something no one has built before: a system with a persistent model of reality that gets smarter by rewriting itself, with a human hand on the kill switch.