Getting Started with Sovereign AI: Your First Recipe

Getting Started with Sovereign AI: Your First Recipe
Start small. Capture one recipe. Then watch the loop compound.
By Daniel Kliewer
Published: July 5, 2026
Reading Time: 15 minutes
Prerequisites: None (beginner to advanced)
This post is a beginner on-ramp — it defines terms and walks you through your first recipe capture. For the full sovereign AI architecture (5-layer stack, compounding intelligence, research validation), see the Sovereign AI Architecture pillar.
Executive Summary
This post is the zero-to-one on-ramp: it defines the three core concepts of sovereign AI (recipe compilation, signal routing, autonomous evaluation) in plain language, then walks you through capturing your first recipe in five steps using the Sovereign Intelligence Stack. If the Sovereign AI Architecture pillar is the full five-layer reference, this is the page you read first — no prerequisites, no code dumps, just the mental model you need before you start building.
What you'll learn:
- What sovereign AI is (and isn't)
- What recipe compilation means
- What signal routing means
- What autonomous evaluation means
- How to get started with the Sovereign Intelligence Stack
- Where to find more advanced resources
Ready for the full architecture? See the Sovereign AI Architecture pillar for the complete 5-layer stack, compounding intelligence design, and research validation.
What is Sovereign AI?
Sovereign AI is the idea that intelligence is not the model. Intelligence is the accumulated decisions that shaped the model.
This means:
- The model is just a snapshot of past decisions
- The loop is what keeps accumulating
- Systems that don't capture decisions are building castles on sand
- Compounding intelligence requires capture, evaluation, and storage
What Sovereign AI Is NOT
- Not just local LLMs — Local LLMs are a component, not the whole system
- Not just agent frameworks — Agent frameworks are tools, not architecture
- Not just RAG — RAG is retrieval, not intelligence
- Not just prompts — Prompts are inputs, not decisions
What Sovereign AI IS
- A compounding system — Gets smarter over time
- A recipe-based system — Captures decisions as immutable records
- A sovereign system — No cloud APIs required, data stays local
- An observable system — Every decision produces a timeline event
Key Concepts
Recipe Compilation
Definition: Capturing AI decisions as immutable records.
Why it matters: Without recipes, you have no history. You have no way to know why a model made a decision, what memory it used, what the outcome was.
What a recipe captures:
- Objective — What was the task?
- Model — Which model was used?
- Memory — What memory was injected?
- Prompt — What was the prompt (with versioning)?
- Reasoning Patterns — What reasoning patterns were used?
- Evaluation — How was it evaluated?
- Result — What was the result?
- Timestamp — When was it captured?
Example:
@dataclass
class Recipe:
objective: str
model: str
memory_snapshot: Optional[str] = None
prompt: Optional[str] = None
reasoning_patterns: List[str] = field(default_factory=list)
evaluation_score: Optional[float] = None
outcome: str = "unknown"
timestamp: datetime = field(default_factory=datetime.now)
tags: List[str] = field(default_factory=list)
Signal Routing
Definition: Classifying incoming tasks and routing them through optimal evaluation paths.
Why it matters: Not all tasks are created equal. Simple tasks should be routed to fast, lightweight models. Complex tasks should be routed to capable models with full context.
Signal Types:
- Cheap — Simple tasks routed to fast, lightweight models
- Expert — Complex tasks routed to capable models with full context
- Hybrid — Tasks that benefit from multi-stage evaluation
Autonomous Evaluation
Definition: Self-improving loops that generate tests, evaluate performance, and detect drift.
Why it matters: Without evaluation, you have no way to know if your system is improving or degrading. Drift detection catches performance regressions before they compound.
Components:
- Signal Registry — Define what to evaluate
- Test Generator — Generate synthetic test cases
- Drift Detector — Detect performance drift (KS and PSI statistics)
- Loop Controller — Autonomous evaluation scheduling
How to Get Started
Step 1: Install the Sovereign Intelligence Stack
# Clone the repository
git clone https://github.com/kliewerdaniel/sovereign-intelligence-stack.git
cd sovereign-intelligence-stack
# Create virtual environment
python -m venv .venv
source .venv/bin/activate
# Install dependencies
pip install -e .
Step 2: Capture Your First Recipe
from src.recipe_compiler.models import Recipe
from src.recipe_compiler.storage import RecipeStorage
storage = RecipeStorage("my_stack.db")
recipe = Recipe(
objective="Generate error handler for API calls",
model="gpt-4",
outcome="accepted",
evaluation_score=0.92,
tags=["error_handling", "api", "reliability"]
)
storage.create_recipe(recipe)
print(f"Recipe captured: {recipe.id}")
Step 3: Run the Full Pipeline
from src.integration.pipe import SovereignPipeline, PipelineConfig
config = PipelineConfig(db_path="intelligence.db")
pipeline = SovereignPipeline(config)
pipeline.initialize()
# Capture a recipe
recipe = Recipe(
objective="Optimize database query",
model="claude-2",
outcome="accepted",
evaluation_score=0.87,
tags=["optimization", "database"]
)
result = pipeline.capture_recipe(recipe)
# Get intelligence summary
summary = pipeline.get_intelligence_summary()
print(summary)
Step 4: Run Autonomous Evaluation
from src.evaluation.loop import EvaluationLoop, LoopConfig
config = LoopConfig(
signal_names=["code_correctness", "performance", "reliability"],
test_count=50,
interval_seconds=60
)
loop = EvaluationLoop(recipe_storage, config)
loop.start()
Step 5: Explore the Intelligence Observatory
from src.observatory.timeline import IntelligenceTimeline
timeline = IntelligenceTimeline(recipe_storage)
timeline.record_event(IntelligenceEvent(
type="recipe_captured",
recipe_id=recipe.id,
timestamp=datetime.now()
))
# Get timeline
events = timeline.get_timeline(days=30)
for event in events:
print(f"{event.timestamp}: {event.type} - {event.recipe_id}")
What's Next?
Start Here
- Read the Sovereign AI Architecture pillar — The complete 5-layer stack, design principles, and research validation
For Beginners
- Read the Sovereign Intelligence Stack post — Deep dive into the 5-layer architecture
- Read the Model Is Not the Product post — Research validation and convergence
For Intermediate Readers
- Read the Sovereign Memory Bank post — 7-layer memory system
- Read the Dynamic Persona MoE RAG post — Persona-driven retrieval
- Read the SovereignSpec post — Spec-driven development
For Advanced Readers
- Read the Loop Is the Product post — Intelligence Observatory deep dive
- Read the Autonomous Sovereign AI post — Autoresearch loops and expert fine-tuning
- Contribute to the sovereign-intelligence-stack repository
FAQ
Is this just local LLMs?
No. Local LLMs are a component. Sovereign AI is the entire architecture: capture, route, evaluate, store, observe.
Do I need to use Ollama?
No. The stack works with any model provider (OpenAI, Anthropic, local LLMs, etc.). Ollama is just one option.
Is this production-ready?
Yes. The stack has 70 Python files, 7,757 lines of code, and 26 modules verified. It's used in production for autonomous research and expert fine-tuning.
Can I use this for my own projects?
Yes. The stack is open-source (MIT license). You can use it for any project, commercial or non-commercial.
What's the difference between this and CrewAI?
CrewAI is a multi-agent framework. The Sovereign Intelligence Stack is a compounding intelligence system that captures decisions, routes tasks, evaluates autonomously, stores knowledge, and observes patterns. It's the operating system that makes all of these pieces work together.
References
Related Posts
- Sovereign AI Architecture — Full 5-layer architecture, compounding intelligence, research validation (the pillar)
- The Sovereign Intelligence Stack — Architecture deep dive
- The Model Is Not the Product — Research validation
- The Loop Is the Product — Companion post
- Building Autonomous Sovereign AI — Autonomous evaluation
- Local AI Architecture — Local AI guide
- Retrieval Architecture — Retrieval guide
Related Repositories
- sovereign-intelligence-stack — Working code
- Sovereign Memory Bank — Memory system
- Dynamic Persona MoE RAG — Retrieval system
- Objective05 — Persistent infrastructure
- SovereignSpec — Spec-driven development
Research Papers
- Residual Context Diffusion Language Models (Hu et al., 2026) — Apple research
- SGLang (LMSYS, UC Berkeley) — Agentic execution graphs
- Context Engineering (13.5K stars) — Systematic replacement for vibe coding
- Agent Harnesses (ECC 225K + Superpowers 244K stars) — Operating system layer for agents
- Persistent Memory (Claude Mem, 85K stars) — Stateful agent collaboration
- Multi-Agent Orchestration (CrewAI, 55K stars) — Collaborative intelligence
- Spec-Driven Development — Structured specifications (117K stars ecosystem)
- GraphRAG (Microsoft, 70K+ stars) — Knowledge graph retrieval
- The Sovereign Intelligence Stack
- The Model Is Not the Product
- The Loop Is the Product
- Building Autonomous Sovereign AI
- Sovereign Memory Bank
- Dynamic Persona MoE RAG
- SovereignSpec
Related Repositories
- sovereign-intelligence-stack
- Sovereign Memory Bank
- Dynamic Persona MoE RAG
- Objective05
- SovereignSpec
Published July 5, 2026 by Daniel Kliewer
License: MIT
The book
Chapter 24: The Sovereign Practice
Chapter 24 §24.1 caps the book with one complete system; the article is the on-ramp to building it.
Related research
Jul 4, 2026
The Sovereign Intelligence Stack: Building Compounding AI Infrastructure
Building a 5-layer architecture where every AI decision compounds into the next layer. The recipe compiler, signal router, autonomous evaluation loop, and more — with working code.
Oct 12, 2026
MindBroadcast — A Technical Specification for a Persistent, Autonomous, News-Driven Intelligence and Broadcasting System
MindBroadcast is a persistent, autonomous broadcasting system that continuously transforms incoming information into an evolving stream of spoken analysis, commentary, and debate. A complete technical specification for a local-first, event-driven, evidence-grounded AI system that maintains an internal model of the world and produces ongoing, persona-driven interpretations.
Sep 4, 2026
The Sovereign Agent Stack — A Local-First, Compile-Time AI Agent Framework
The Sovereign Agent Stack (SAS) is a local-first, compile-time AI agent framework that operationalizes the sovereignty thesis from The Rented Sovereign. A complete 7-layer architecture with 156 tests, 23 E2E tests, plugin system, MCP server, and package manager distribution.
Aug 9, 2026
Hermes Atlas v0.1: A Local-First, Incrementally-Compiled, Falsifiable Knowledge System
Hermes Atlas v0.1 is a local-first, incrementally-compiled, falsifiable knowledge system. This is a full replication guide: every command was run for real, and the failure modes are the findings.
Aug 9, 2026
Hermes Atlas v0.2: Claim-Level Coverage, a Determinism Gate, and a Knowledge-Mutation Canary
Hermes Atlas v0.2 is a benchmark-and-fix release: claim-level coverage localisation, a determinism gate that proves compile reproducibility, and a knowledge-mutation canary. Every number below was measured, not asserted.
Aug 9, 2026
Hermes Atlas v0.3: An Evidence Ledger, a Provable Claim Lifecycle, and an Explain Command
Hermes Atlas v0.3 adds an evidence ledger to every claim, a provable claim lifecycle (including DELETE-driven invalidation that retains history), and an `atlas explain` command. Every number below was measured, not asserted.