The Model Is Not the Product: Residual State, Compiled Agents, and Optimization Loops

The Model Is Not the Product: Residual State, Compiled Agents, and Optimization Loops

July 3, 2026

The model is no longer the product. The loop is.

That idea keeps getting reinforced every time I look at new research from Apple, LMSYS, and the recent work on autoresearch and constrained optimization. They're not converging on a better chatbot. They're converging on something closer to a reconfigurable system of computation where "reasoning" is just one phase inside a larger machine.

What's changing isn't just capability. It's where intelligence lives.

It's shifting out of the model and into three places at once: residual state, execution graphs, and optimization loops.

This isn't abstract. Each of these threads has concrete implementations — and when you wire them together, you get something that looks less like a chatbot and more like a continuously recompiled cognitive engine. I've been building toward this architecture across several systems: Objective05 (persistent intelligence infrastructure in Rust), Sovereign Memory Bank (7-layer autonomous cognitive memory), Dynamic Persona MoE RAG (persona-driven mixture-of-experts over local graphs), and SovereignSpec (spec-driven development with GraphRAG). This post is the synthesis of what those systems are converging on — and what the research confirms.

1. From Tokens to Residual State

Apple's Residual Context Diffusion

Apple's Residual Context Diffusion (RCD) quietly breaks one of the core assumptions behind most LLM systems: that intermediate uncertainty should be discarded.

Paper: Residual Context Diffusion Language Models — arXiv:2601.22954 (Hu et al., 2026) Code: github.com/yuezhouhu/residual-context-diffusion

In standard generation pipelines, we sample, reject, and move on. Low-confidence paths disappear. Only the final sequence matters.

RCD changes that. Instead of throwing away "failed" intermediate states during diffusion, it feeds them forward as contextual residuals — entropy-weighted continuous embedding vectors injected into subsequent denoising steps.

Here's the core mechanism in pseudocode:

import torch
import torch.nn.functional as F

def residual_diffusion_step(
    x_t: torch.Tensor,           # masked embedding at step t
    logits: torch.Tensor,        # model logits over vocabulary
    embed_weight: torch.Tensor,  # vocabulary embedding matrix
    residual_buffer: list,       # accumulated residuals from prior steps
    temperature: float = 1.0,
    entropy_threshold: float = 0.5,
) -> tuple[torch.Tensor, torch.Tensor]:
    """
    One step of RCD decoding.

    Instead of hard-committing to argmax tokens and discarding the rest,
    RCD converts the full predictive distribution into a residual vector
    and feeds it forward into the next step.
    """
    # Compute token probabilities
    probs = F.softmax(logits / temperature, dim=-1)

    # Entropy-weighted residual: sum over vocab weighted by uncertainty
    # High-entropy (uncertain) positions contribute more residual signal
    entropy = -(probs * torch.log(probs + 1e-8)).sum(dim=-1, keepdim=True)
    normalized_entropy = entropy / entropy.max()

    # Residual = weighted sum of all vocabulary embeddings
    # NOT just the argmax token — every candidate contributes
    residual = torch.einsum("b v, v d -> b d", probs, embed_weight)
    residual = residual * (normalized_entropy > entropy_threshold).float()

    # Accumulate residual into buffer
    residual_buffer.append(residual.detach())

    # Blend: combine original masked embedding with residual history
    # The mixing weight is itself entropy-dependent
    blend_weight = torch.sigmoid(2.0 * normalized_entropy - 1.0)
    x_next = (1 - blend_weight) * x_t + blend_weight * residuals.mean(dim=0)

    return x_next, probs

That sounds like a small tweak. It isn't.

Results: RCD achieves 5–10 point accuracy gains on frontier diffusion LLMs, nearly 2× baseline on AIME, and 4–5× fewer denoising steps at equivalent accuracy — all from converting a standard dLLM with ~300M tokens of additional training. The paper shows this works because the residual buffer captures discarded hypotheses, low-probability reasoning paths, and partial structures that didn't resolve cleanly — everything we normally optimize away becomes state for the next iteration.

What This Means for System Architecture

In most LLM systems (including RAG), memory is treated as retrieval:

def standard_rag(query: str, top_k: int = 5) -> str:
    embedding = embedder.embed(query)
    results = vector_store.similarity_search(embedding, k=top_k)
    return format_context(results)

But RCD suggests a different model:

Memory is not retrieval. Memory is residue.

In my Sovereign Memory Bank architecture (post, repo), I implemented exactly this principle through the 7-layer memory hierarchy. Layer 0 (source) and Layer 1 (extracted concepts/claims/entities) are the residual accumulation layer — nothing is discarded, everything feeds forward:

# From Sovereign Memory Bank's memory hierarchy:
# Every extraction round preserves all intermediate representations
# as first-class graph nodes, regardless of "confidence"

class ExtractedClaim(BaseModel):
    text: str
    source_chunk_id: str
    confidence: float  # low-confidence claims are NOT filtered — they persist
    residual_embedding: list[float]  # distributional residual, not just argmax
    extraction_round: int  # provenance for evolution tracking
    status: Literal["candidate", "verified", "contradicted", "superseded"]

The principle is structural: even failure becomes state. In the context of Dynamic Persona MoE RAG (post, repo), this means a persona that produces a low-confidence response doesn't get ignored — its partial output feeds into the next persona's conditioning. The activation_cost and historical_performance fields on each persona schema become the residual signal that shapes future routing decisions.

2. From Tool Use to Executable Systems

LMSYS and SGLang Agents

The LMSYS work on agent-assisted SGLang development pushes the next abstraction shift: the agent is no longer just a consumer of tools. It becomes part of the system that defines execution.

Paper: SGLang: Efficient Execution of Structured Language Model Programs — arXiv:2312.07104 (Zheng et al., NeurIPS 2024) Repo: github.com/sgl-project/sglang (29.9k+ stars, 400k+ GPUs in production)

Instead of:

prompt → model → tool call → result

We start seeing:

agent → compiles execution graph → optimizes inference paths → rewrites runtime behavior → executes

SGLang already treats inference as a structured program through its Python-embedded DSL with primitives like gen, select, fork, join, and extend. What the agent layer adds is adaptability at the level of the execution graph itself.

Here's how SGLang represents a multi-step inference as a compilable graph:

import sglang as sgl

@sgl.function
def multi_step_reasoning(context: str, question: str):
    """
    SGLang compiles this into a computational graph
    that the runtime can optimize via code motion,
    instruction selection, and auto-tuning.
    """
    # Step 1: Analyze context
    analysis = sgl.gen("analysis", max_tokens=256)
    
    # Step 2: Fork — explore multiple reasoning paths in parallel
    fork_context = sgl.fork(3)
    with fork_context:
        hypothesis_1 = sgl.gen("path_1", max_tokens=128, temperature=0.3)
        hypothesis_2 = sgl.gen("path_2", max_tokens=128, temperature=0.7)
        hypothesis_3 = sgl.gen("path_3", max_tokens=128, temperature=0.9)
    
    # Step 3: Join — synthesize across paths
    sgl.join()
    synthesis = sgl.gen("synthesis", max_tokens=256)
    
    # Step 4: Constrained decode — output must match JSON schema
    final = sgl.gen(
        "final",
        max_tokens=512,
        schema={
            "type": "object",
            "properties": {
                "answer": {"type": "string"},
                "confidence": {"type": "number"},
                "reasoning_paths": {
                    "type": "array",
                    "items": {"type": "string"}
                }
            },
            "required": ["answer", "confidence"]
        }
    )
    return final

The runtime applies RadixAttention — a radix-tree LRU cache for KV tensors that enables automatic prefix reuse across calls. If the same context prefix appears in a later query, the KV cache is reused rather than recomputed. This gives up to 6.4× higher throughput vs vLLM on agent/reasoning/RAG/multi-turn workloads.

The critical architectural property: the execution graph is mutable at runtime. An agent can observe its own inference pattern and rewrite the execution graph — adding branches, merging paths, reordering operations — by generating new SGLang programs that describe the next iteration's structure.

What This Means for System Architecture

This matters because it dissolves the boundary between "model reasoning" and "system architecture."

The agent is no longer sitting on top of the stack. It is partially responsible for constructing the stack on each run.

Most agent frameworks today assume:

• Static tool definitions
• Fixed orchestration logic
• Stable execution pipelines

But real systems under SGLang-style design become:

• Dynamic execution graphs
• Query-dependent compilation
• Runtime-optimized inference paths

In my Objective05 architecture (post, repo), this maps directly onto the EventEngine and SchedulerService pattern. The scheduler emits typed events onto a message bus; pipeline workers consume events and dispatch to ingestion/extraction/correlation/maintenance functions. The critical insight from Objective05 is that the pipeline topology itself is query-dependent — different document types trigger different extraction chains, and the correlation engine's merge logic is parameterized by entity type and temporal proximity:

// From Objective05's EventEngine design:
// Execution paths are not fixed — they're compiled per event type

enum PipelineStage {
    Ingest { source: SourceAdapter },
    Extract { method: ExtractionMethod },   // heuristic vs LLM
    Correlate { threshold: f64 },           // merge threshold per entity type
    Maintain { action: MaintenanceAction }, // archive, promote, notify
}

struct ExecutionGraph {
    stages: Vec<PipelineStage>,             // compiled per event class
    cache_hint: Option<RadixKey>,           // KV cache strategy
    timeout: Duration,                      // budget constraint
}

impl SchedulerService {
    fn compile_graph(&self, event: &Event) -> ExecutionGraph {
        // The execution graph is generated — not hardcoded
        match event.class {
            EventClass::Financial => ExecutionGraph {
                stages: vec![
                    PipelineStage::Extract { method: ExtractionMethod::LLM },
                    PipelineStage::Correlate { threshold: 0.85 },
                ],
                cache_hint: Some(RadixKey::from(event.entity_id())),
                timeout: Duration::from_secs(30),
            },
            EventClass::Social => ExecutionGraph {
                stages: vec![
                    PipelineStage::Extract { method: ExtractionMethod::Heuristic },
                    PipelineStage::Correlate { threshold: 0.6 },
                    PipelineStage::Maintain { action: MaintenanceAction::Flag },
                ],
                cache_hint: None,  // social events have low cache reuse
                timeout: Duration::from_secs(10),
            },
        }
    }
}

Which leads to a harder conclusion:

If the execution graph is mutable, then "the system" is not static software. It is a generated artifact. And agents are compilers.

3. From Loops to Constrained Optimization

Autoresearch Systems as Formal Search Spaces

The third piece is more subtle, but it completes the picture.

Autoresearch-style systems framed through constrained optimization treat agent loops not as "iteration until better answer," but as structured search over a bounded space of possible reasoning trajectories.

Key references:

• Karpathy's autoresearch — github.com/karpathy/autoresearch: minimal agent loop (700 experiments in 2 days on H100, 20 optimizations discovered)
• Bilevel Autoresearch (Qu & Lu, 2026) — arXiv:2603.23420: outer loop optimizes inner loop's search mechanism
• Agent Contracts (Ye & Tan, 2026) — arXiv:2601.08815: formal resource-bounded agent execution with conservation laws
• CCPO (Si et al., 2026) — arXiv:2511.11828: conformal constrained policy optimization for cost-effective agents
• EvoTrainer (2026) — arXiv:2606.03108: co-evolving LLM policies and training harnesses

Instead of:

generate → critique → refine → repeat

We get:

explore hypothesis space → evaluate against constraints → allocate compute dynamically → converge under budgeted uncertainty

Here's what that looks like as a formal optimization loop:

from dataclasses import dataclass
from enum import Enum
from typing import Callable, Generic, TypeVar

State = TypeVar("State")
Action = TypeVar("Action")

class ResourceConstraint(Enum):
    TOKENS = "tokens"
    API_CALLS = "api_calls"
    ITERATIONS = "iterations"
    LATENCY_MS = "latency_ms"
    COST_USD = "cost_usd"

@dataclass
class Budget:
    """Formal resource budget from the Agent Contracts framework."""
    limits: dict[ResourceConstraint, float]
    consumed: dict[ResourceConstraint, float]

    def remaining(self, constraint: ResourceConstraint) -> float:
        return self.limits.get(constraint, float("inf")) - self.consumed.get(constraint, 0.0)

    def within_budget(self) -> bool:
        return all(
            self.consumed.get(k, 0.0) <= v
            for k, v in self.limits.items()
        )

@dataclass
class Trajectory:
    """A complete reasoning trajectory, not just the final answer."""
    steps: list[tuple[State, Action, float]]  # state, action, reward
    total_cost: float
    total_tokens: int

class ConstrainedOptimizationLoop(Generic[State, Action]):
    """
    An agent loop framed as constrained optimization over
    a bounded space of reasoning trajectories.

    Reference: CCPO (Si et al., 2026) + Agent Contracts (Ye & Tan, 2026)
    """

    def __init__(
        self,
        explore_policy: Callable[[State, Budget], Action],
        exploit_policy: Callable[[State, Budget], Action],
        evaluate: Callable[[Trajectory], float],
        budget: Budget,
        confidence_target: float = 0.95,
    ):
        self.explore = explore_policy   # cheap model for exploration
        self.exploit = exploit_policy   # expensive model for exploitation
        self.evaluate = evaluate        # objective function
        self.budget = budget
        self.confidence_target = confidence_target
        self.trajectories: list[Trajectory] = []

    def step(self, state: State) -> Action:
        """Adaptive action selection based on remaining budget and uncertainty."""
        uncertainty = self._estimate_uncertainty(state)
        remaining = self.budget.remaining(ResourceConstraint.TOKENS)

        # The explore/exploit decision is itself computed — not hardcoded
        if uncertainty > self.confidence_target and remaining > 1000:
            # Explore: cheap model, wide search
            return self.explore(state, self.budget)
        else:
            # Exploit: expensive model, precise answer
            return self.exploit(state, self.budget)

    def _estimate_uncertainty(self, state: State) -> float:
        """Conformal prediction over past trajectory outcomes."""
        if len(self.trajectories) < 10:
            return 1.0  # maximum uncertainty, always explore early
        return 1.0 - self._coverage_estimate()

    def _coverage_estimate(self) -> float:
        """Empirical coverage of correct answers in prediction sets."""
        correct = sum(1 for t in self.trajectories[-20:] if t.steps[-1][2] > 0.5)
        return correct / min(len(self.trajectories), 20)

The key shift is that the loop is no longer informal.

It has geometry:

• Constraints (compute, latency, hallucination risk, API budget)
• Objectives (accuracy, novelty, coherence, utility)
• Tradeoffs between exploration and exploitation, formalized via conformal prediction

This is important because it forces something most agent systems avoid: you have to define what "better" actually means in system terms.

In my Building Autonomous Sovereign AI post, I described this as the Inner Loop vs Outer Loop separation. The Inner Loop executes tasks; the Outer Loop observes performance and drives improvement. The Karpathy-style autoresearch system is the purest form — a model edits its own training script, runs for exactly 5 minutes, measures val_bpb, and keeps or discards the change. The binary keep/discard criterion is the objective function. The 5-minute wall-clock window is the resource constraint. The single editable file (train.py) is the trust boundary.

# From Karpathy's autoresearch pattern:
# The loop is the product. The model is a component.

class AutoresearchLoop:
    """
    Minimal constrained optimization over research trajectories.

    Key design decisions:
    - Fixed time budget per experiment (5 min)
    - Single mutable file (train.py)
    - Binary acceptance criterion (val_bpb improvement)
    """

    def __init__(self, experiment_dir: Path, time_budget_s: int = 300):
        self.experiment_dir = experiment_dir
        self.time_budget_s = time_budget_s
        self.history: list[ExperimentResult] = []
        self.best_bpb = float("inf")

    def propose_change(self, model, context: str) -> str:
        """Generate a code change hypothesis."""
        prompt = f"""Current validation bits-per-byte: {self.best_bpb:.4f}
History: {len(self.history)} experiments, {'improving' if self._trend() > 0 else 'plateauing'}

Propose a single-file change to train.py that could improve val_bpb.
Strategy: {context}
Return ONLY the diff."""
        diff = model.generate(prompt)
        return diff

    def execute(self, diff: str) -> ExperimentResult:
        """Apply change, run with fixed budget, measure outcome."""
        backup = (self.experiment_dir / "train.py").read_text()
        try:
            # Apply proposed change
            result = subprocess.run(
                ["git", "apply"],
                input=diff, text=True, capture_output=True, cwd=self.experiment_dir
            )
            if result.returncode != 0:
                return ExperimentResult(diff=diff, val_bpb=None, accepted=False)

            # Run with hard time budget
            start = time.time()
            proc = subprocess.run(
                ["python", "train.py"],
                timeout=self.time_budget_s, cwd=self.experiment_dir,
                capture_output=True, text=True
            )
            elapsed = time.time() - start

            # Parse validation metric
            val_bpb = self._parse_val_bpb(proc.stdout)
            accepted = val_bpb is not None and val_bpb < self.best_bpb
            if accepted:
                self.best_bpb = val_bpb

            return ExperimentResult(
                diff=diff, val_bpb=val_bpb,
                elapsed_s=elapsed, accepted=accepted
            )
        finally:
            (self.experiment_dir / "train.py").write_text(backup)

    def _trend(self) -> float:
        if len(self.history) < 5:
            return 0.0
        recent = [r.val_bpb for r in self.history[-5:] if r.val_bpb is not None]
        return (recent[0] - recent[-1]) / len(recent) if len(recent) >= 2 else 0.0

The Bilevel Autoresearch extension (Qu & Lu, 2026) takes this further: the outer loop doesn't just propose changes to the training script — it generates the search strategy itself (Tabu Search, Bandit, Orthogonal Exploration) as executable Python code, achieving 5× improvement over the inner loop alone.

4. Putting It Together: Residual Systems, Compiled Agents, and Optimization Loops

These three threads — Apple's residual diffusion framing, LMSYS's execution graph agents, and autoresearch/constrained optimization — aren't separate ideas. They're three layers of the same transition.

They map cleanly onto a new system stack that my projects are converging on:

Layer 1: Residual State (Memory)

• Not retrieval-based RAG
• But persistent accumulation of: failed reasoning, partial structures, unresolved hypotheses
• Memory becomes a living substrate, not a lookup table

In Sovereign Memory Bank (post, repo), this is Layers 0–2 of the 7-layer hierarchy: source documents → extracted concepts/claims/entities → structured relationships. The evolution engine autonomously merges, splits, promotes, and deprecates nodes based on incoming evidence — exactly the RCD principle applied at system scale.

Layer 2: Execution Graphs (Compute)

• Not static tool calling
• But dynamic inference compilation
• Agents participate in shaping runtime structure
• Execution becomes query-specific and mutable

In SovereignSpec (post, repo), this is the 12-step compilation pipeline: parse → validate → resolve_deps → check_contradictions → compute_drift → generate_plan → generate_tasks → generate_context → generate_docs → update_knowledge_graph → update_embeddings → commit_version. Each invocation compiles a new execution graph for the spec being processed, with the GraphEngine computing dependency chains and impact analysis via NetworkX.

In Objective05 (post, repo), the SchedulerService emits typed events onto a message bus — pipeline workers consume and dispatch to ingestion/extraction/correlation/maintenance functions. The pipeline topology per event is not hardcoded; it's compiled per event class with different cache strategies, timeouts, and processing chains.

Layer 3: Constrained Loops (Reasoning)

• Not open-ended generation
• But optimization over trajectories
• Bounded by compute, uncertainty, and objective functions

In the Dynamic Persona MoE RAG system (post, repo), the routing decision (which persona to activate for a query) is itself a constrained optimization. Each persona has an activation_cost; the router balances persona expertise against total compute budget. The historical_performance field feeds back into the routing policy, creating the explore/exploit dynamic formalized by CCPO.

# From Dynamic Persona MoE RAG: persona routing as constrained optimization

@dataclass
class Persona:
    name: str
    expertise: list[str]
    traits: dict[str, float]  # 1-9 scale
    activation_cost: int      # tokens consumed per invocation
    historical_performance: float  # running accuracy score
    last_activated: float      # timestamp for recency weighting

class ConstrainedPersonaRouter:
    """
    Routes queries to personas under resource constraints.

    This is the Layer 3 (Constrained Loops) instantiation in MoE RAG.
    """

    def __init__(self, personas: list[Persona], budget: Budget):
        self.personas = personas
        self.budget = budget

    def select(
        self,
        query: str,
        query_embedding: list[float],
        top_k: int = 3,
    ) -> list[Persona]:
        """
        Select top-k personas under budget constraints.

        Uses a scoring function that blends:
        1. Semantic similarity (query → persona expertise)
        2. Activation cost penalty
        3. Historical performance bonus
        4. Recency bonus (favor recently validated personas)
        """
        candidates = []
        remaining_tokens = self.budget.remaining(ResourceConstraint.TOKENS)

        for persona in self.personas:
            if persona.activation_cost > remaining_tokens:
                continue  # prune — violates budget constraint

            # Similarity + cost-aware scoring
            expertise_sim = cosine_similarity(query_embedding, persona_expertise_embedding(persona))
            cost_penalty = persona.activation_cost / 1000
            perf_bonus = persona.historical_performance * 0.3

            score = expertise_sim - cost_penalty + perf_bonus
            candidates.append((score, persona))

        candidates.sort(key=lambda x: x[0], reverse=True)
        selected = [p for _, p in candidates[:top_k]]

        # Deduct from budget
        total_cost = sum(p.activation_cost for p in selected)
        self.budget.consumed[ResourceConstraint.TOKENS] = (
            self.budget.consumed.get(ResourceConstraint.TOKENS, 0) + total_cost
        )

        return selected

The Unified Architecture

When combined, something new emerges:

A system where intelligence is not located in the model, but in the interaction between:

• residual memory (Sovereign Memory Bank, RCD)
• compiled execution (SGLang agents, Objective05 EventEngine, SovereignSpec pipeline)
• constrained iteration (autoresearch loops, CCPO, Dynamic MoE RAG router)

This is the architecture I described in the Sovereign Synthesis — the 7-layer unified architecture where Interface (Next.js) → API (FastAPI) → Orchestration (MoE/DeerFlow) → Governance (Control Boundary) → Reasoning (Persona Engine/SpecGen) → Memory (NetworkX + ChromaDB) → Inference (Ollama/llama.cpp). The three layers in this post (residual state, execution graphs, constrained loops) map directly onto the Memory, Reasoning, and Governance layers of the Synthesis.

5. What This Implies for Agent Systems

If you're building something like Dynamic Persona MoE RAG, Hermes-style orchestration, Objective05, Sovereign Memory Bank, or any autoresearch loop system, the implication is simple but uncomfortable:

Most current architectures are only simulating parts of this stack.

• RAG simulates memory, but discards residue
• Tool-using agents simulate execution, but don't compile graphs
• Prompt loops simulate optimization, but don't formalize objectives

The next step is not "better prompting" or "bigger models."

It is structural:

1. Stop treating failed outputs as waste. Treat them as state. — Implement residual accumulation (RCD-style) in your memory layer. Sovereign Memory Bank's evolution engine does this; so does Objective05's event merge pattern.

2. Stop treating execution as fixed. Treat it as compiled per query. — Generate execution graphs at runtime. Objective05's compile_graph() and SovereignSpec's 12-step pipeline are examples. SGLang shows how to make this efficient with RadixAttention.

3. Stop treating iteration as narrative. Treat it as constrained optimization. — Formalize your budget, objective function, and explore/exploit policy. CCPO and Agent Contracts provide the mathematical framework. Karpathy's autoresearch shows the minimal viable implementation.

Once you do that, the system stops looking like an LLM application.

It starts looking like a continuously recompiled cognitive engine.

6. Closing

The model is not the product anymore because it was never the full system in the first place.

What's emerging now is something closer to a programmable cognition substrate:

• memory that accumulates error as structure
• execution that compiles itself per task
• reasoning that optimizes under constraint

In that world, the interesting question is no longer:

"What can the model do?"

It becomes:

"What kind of loop are you running, and what does it optimize for?"

And that's where everything starts to converge.

References

1. Hu et al. Residual Context Diffusion Language Models. arXiv:2601.22954, 2026
2. Zheng et al. SGLang: Efficient Execution of Structured Language Model Programs. arXiv:2312.07104, NeurIPS 2024
3. Karpathy. autoresearch. GitHub, 2026
4. Qu & Lu. Bilevel Autoresearch. arXiv:2603.23420, 2026
5. Ye & Tan. Agent Contracts: A Formal Framework for Resource-Bounded Autonomous AI Systems. arXiv:2601.08815, 2026
6. Si et al. Conformal Constrained Policy Optimization for Cost-Effective LLM Agents. arXiv:2511.11828, AAAI 2026
7. Harris & Slivkins. Should You Use Your LLM to Explore or Exploit?. arXiv:2502.00225, 2026
8. EvoTrainer. Co-Evolving LLM Policies and Training Harnesses. arXiv:2606.03108, 2026

Related Posts

• The Model Is Not the Product: On Building Persistent Intelligence Infrastructure — Objective05 deep dive
• Building Autonomous Sovereign AI: Autoresearch Loops and Expert Fine-Tuning — Inner/outer loop architecture
• Sovereign Memory Bank: Autonomous Cognitive Memory for Agent Systems — 7-layer memory hierarchy
• Dynamic Persona MoE RAG: Building Memory-Driven Synthetic Intelligence — Persona-based constrained routing
• SovereignSpec: Local-First Spec-Driven Development — 12-step compilation pipeline
• SOVEREIGN: The Unified Architecture — 7-layer convergent architecture
• Context Engineering: The Blind Spots and the Real Full-Stack Development Paradigm — Agent harnesses and persistent memory

Related Posts

• The Sovereign Intelligence Stack — Architecture implementation with working code
• The Loop Is the Product — Intelligence Observatory deep dive
• Building Autonomous Sovereign AI — Autoresearch loops and expert fine-tuning
• Getting Started with Sovereign AI — Beginner on-ramp
• Local AI Architecture — Local-first implementation guide
• Retrieval Architecture — Memory and retrieval systems

Related Repositories

• sovereign-intelligence-stack — 70 Python files, 7,757 lines
• sovereign-memory-bank — Autonomous cognitive memory
• dynamic-persona-moe-rag — Persona-driven MoE
• objective05 — Rust persistent intelligence infrastructure
• sovereignspec — Spec-driven development

Additional Research

• LMSYS/SGLang — Agentic execution graphs
• Bridgewater AIA Labs — Autonomous evaluation
• Thinking Machines Lab — Compounding intelligence
• Apple Research — Residual Context Diffusion team
• Autonomous Agent Research — arXiv search
• Compounding Intelligence Research — arXiv search