Skip to content
Daniel Kliewer

Getting Started with Sovereign AI: Your First Recipe

By
7 min read
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

  1. Read the Sovereign AI Architecture pillar — The complete 5-layer stack, design principles, and research validation

For Beginners

  1. Read the Sovereign Intelligence Stack post — Deep dive into the 5-layer architecture
  2. Read the Model Is Not the Product post — Research validation and convergence

For Intermediate Readers

  1. Read the Sovereign Memory Bank post — 7-layer memory system
  2. Read the Dynamic Persona MoE RAG post — Persona-driven retrieval
  3. Read the SovereignSpec post — Spec-driven development

For Advanced Readers

  1. Read the Loop Is the Product post — Intelligence Observatory deep dive
  2. Read the Autonomous Sovereign AI post — Autoresearch loops and expert fine-tuning
  3. 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

Related Repositories

Research Papers

Related Repositories


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.

More from the archive