Epistemic Engines: Building Reflective Minds with Belief Cartridges and In-Context Learning

🔍 Summary: Building the Engine of Understanding

This is not a finished story. It’s the beginning of one and likely the most ambitious post we’ve written yet.

We’re venturing into new ground: designing epistemic engines modular, evolving AI systems that don’t just respond to prompts, but build understanding, accumulate beliefs, and refine themselves through In-Context Learning.

In this series, we’ll construct a self-contained system separate from our core framework Stephanie that runs its own pipelines, evaluates its own beliefs, and continuously improves through repeated encounters with new data. Its core memory will be made of cartridges: scored, structured markdown artifacts distilled from documents, papers, and the web. These cartridges form a kind of belief substrate that guides the system’s judgments.

This post marks the beginning of that journey. We’ll lay out:

• What a worldview is in our system
• How it learns using In-Context Learning and dynamic prompting
• How it distills information into structured, re-usable belief cartridges
• And how it tunes its understanding over time

This is still in progress. We don’t know exactly how far it can go. But we believe it’s the right direction and over the next few blog posts, we’ll build it piece by piece, with code, agents, pipelines, and the guiding question:

❗ The Upper Bound Problem: Why We’re Building This

If the intelligence of our system is capped by the intelligence of the language model it uses, then self-learning becomes a fantasy.

This is the core challenge.

We’ve built agents. Pipelines. Feedback loops. But at every step, we’ve relied on a large language model to do the thinking. And what we’re beginning to realize is unsettling:

If the model can’t understand something, neither can the system.

This dependency creates a hard upper limit. And that’s not just a technical bottleneck it’s an epistemological one. Our self-improving AI can’t truly improve if it inherits all the limits of its foundation model.

That’s the motivation for this new direction.

We’re designing something that thinks beyond its model a system that uses models as tools, but is not defined by them. Something that builds a body of knowledge, that can reason over it, refine it, and grow from it.

That’s what these worldviews, belief cartridges, and in-context learning pipelines are about.

They’re not just artifacts. They’re an attempt to answer this question:

Can we build something smarter than the model it uses?

And if we can, what’s the architecture of such a thing?

🧠 How Humans Learn: A Lifelong Dialogue with Reality

Every human being begins life with an empty mind a blank slate. An infant has no beliefs, no concepts, no understanding of the world. But through interaction with caregivers, objects, language, and the environment, it gradually starts to build a mental model of reality.

This process is slow, sometimes painstaking. A child learns what is safe, what is dangerous, what brings comfort or frustration. Bit by bit, experiences are absorbed and beliefs begin to form about people, about objects, about cause and effect. These beliefs become the internal scaffolding through which future experiences are interpreted.

Most of the time, beliefs are updated incrementally, through repetition and reflection. But sometimes in moments of shock, insight, or revelation a belief can shift instantly. These rare moments of rapid reconfiguration are as human as the slow grind of learning itself.

By adulthood, a person carries a dense, interconnected worldview: a map of what they believe is true, what they’ve found to be false, and how they expect the world to behave. This worldview filters new information. It accepts some inputs, rejects others. It evolves when it must.

This is what we’re mimicking. Not biology but the process of building, maintaining, and transforming a living model of understanding.

🧠→💻 Modeling the Mind: Worldviews as Isolated Learning Units

In our system Stephanie we’re adopting this idea of a developing mind and translating it into a modular, controllable software construct: the worldview.

Each worldview represents a bounded, evolving mental model tailored to a specific task or goal. When Stephanie is given a challenge say, to explore the latest research on self-improving AI it doesn’t rely on some monolithic knowledge base. Instead, it spawns a worldview: an isolated pocket of understanding built from scratch, using only the information relevant to that goal.

This approach allows us to reason cleanly, avoid contamination from irrelevant knowledge, and observe how understanding grows over time. Like a human child confronting a new subject, Stephanie begins with no beliefs. It learns by reading, evaluating, scoring, and iterating. Over time, the worldview becomes richer, more selective, and more capable of filtering signal from noise.

This blog post walks through how we structure, grow, evaluate, and ultimately extract belief systems from these worldviews building not just software that uses large language models, but systems that learn, evolve, and form beliefs of their own.

🎯 Why Worldviews Work: Tunable, Branchable, and Infinitely Scalable Minds

What makes the worldview such a powerful construct isn’t just that it mimics how people learn it’s that, unlike people, we can tune it relentlessly.

Each worldview is an isolated unit of cognition. It has:

• A singular goal it’s trying to achieve.
• Access to pipelines, models, and tools to process and learn from data.
• A growing internal structure of beliefs, scores, and memories.

Because it’s bounded and goal-directed, we can do things with worldviews that we can’t easily do with complex entangled systems:

• Clone them to try different learning strategies in parallel.
• Merge them when two streams of insight prove compatible.
• Score and audit them to detect progress, bias, or stagnation.
• Branch and tune them endlessly, like a symbolic mind that can fork and evolve.

This gives us our own kind of intelligence. Not a single LLM doing its best guess, but a dynamic network of evolving minds, each sharpening itself around a specific challenge. This is where the self-learning system becomes real not through static weights or memorized answers, but through directed evolution of thought toward measurable, auditable, and eventually useful beliefs.

We’re no longer at the mercy of a single model’s limitations. Each worldview is a small experiment in directed cognition and we can run as many as we want.

🧠 The Core Components: Worldviews and Cartridges

To bring this concept to life, we need a system that can learn in a modular, trackable, and extensible way. At the heart of that system are two foundational components:

1. Worldview (the container)

Each worldview is a self-contained memory space a private, local mind. For now, we’re implementing this as a lightweight SQLite database, but conceptually it could be anything: an API layer, a vector store, or a custom memory graph.

What matters is that it holds:

• The goal it was created for.
• The data it has encountered.
• The beliefs it has formed.
• The pipelines and tools it used to get there.

Each worldview is shaped by its goal and is allowed to think, explore, and evolve independently. This isolation gives us a clean canvas for learning.

2. Cartridges (the output)

At the end of every worldview run, we generate a Cartridge. This is the distilled output of that worldview’s thinking process its best shot at solving or contributing to the original goal.

A cartridge is a Markdown file.

But not just any Markdown.

It’s written in a structured, simplified format with:

• Clear headings for context.
• Bullet points for key takeaways.
• Minimal, high-signal language for fast comprehension.
• Optional code blocks or citations when needed.

Why Markdown? Because it’s universally parsable by humans and models. Markdown is fast, interpretable, and transparent a belief format that’s easy to feed back into the system for future reasoning.

A Cartridge might represent:

• A hypothesis.
• A ranked summary of a research paper.
• A new approach to solving a task.
• A set of learned rules or conclusions.

These cartridges become the re-usable building blocks of intelligence across the system. And just like beliefs in a human mind, they can be edited, scored, trusted or discarded.

🧠 Belief Cartridges: The AI’s Working Memory

At the heart of our epistemic engine lies the belief cartridge a modular, reusable, and inspectable unit of learned knowledge.

These cartridges aren’t just summaries or notes. They’re structured representations of insight: distilled fragments of experience, synthesized conclusions, or reusable patterns derived from the system’s own reasoning and research. They allow Stephanie to store, reuse, score, and evolve what it learns one thought at a time.

🧩 What is a Belief Cartridge?

A belief cartridge is a Markdown file with a minimal, consistent structure designed for both machine and human readability. It includes:

• ✅ A summary of insight
• 📄 A source citation
• 📈 A usefulness score
• 🏷️ Optional domain tags, rationale, and trace metadata

For example:

# Belief: Symbolic Control Improves Stability

- **Summary**: Hybrid symbolic-LLM control reduces erratic behavior in multi-agent reasoning.
- **Source**: arXiv:2405.12345
- **Rationale**: Outperforms pure LLM in planning benchmarks with fewer failures.
- **Score**: 0.88
- **Domains**: reasoning, symbolic learning, agent control

This format makes it easy for downstream agents, LLMs, or reasoning loops to parse and reuse cartridges as examples, constraints, or priors in new tasks.

♻️ How Cartridges Are Created

Belief cartridges are typically created as the final output of a worldview pipeline. After ingesting documents, reasoning about goals, and scoring candidates, the system synthesizes its best understanding into one or more cartridges.

This can happen:

• 📚 After summarizing and scoring a research paper
• 🔁 After a self-reflection or feedback cycle
• 💡 After synthesizing insights across multiple sources

🎯 What they add

• Scalable Memory: They persist across runs and goals, forming the long-term memory of the system.
• Selective Attention: Only high-value beliefs (high score, relevant domain) are retained and reused.
• ICL-Ready: Cartridges can be directly injected as few-shot examples or constraints during in-context learning.
• Composable Intelligence: Multiple cartridges can be combined to guide complex tasks just like citing multiple sources when writing a research paper.

🛠️ Usage in the System

Belief cartridges are not static:

• They are scored using MR.Q and human-like heuristics.
• They are classified into semantic domains for retrieval.
• They can be debated, merged, revised, or retired based on new evidence.

Over time, this collection forms an explicit, interpretable belief system a symbolic mind that grows through experience and iteration.

🔑 The Takeaway

Belief cartridges turn fleeting insights into durable, usable knowledge. They let the system learn from itself, evolve its worldview, and act with growing autonomy. More than just memory they are the building blocks of machine understanding.

🔄 From Belief to Action: Cartridges as Thinking Fuel

Once we’ve collected and scored a series of cartridges belief units derived from previous processing runs we don’t just store them in a drawer and forget about them. These beliefs become the system’s prior knowledge, the lived experience of that worldview.

When the system encounters a new goal or problem, it starts by reaching into its belief system:

“Have I seen something like this before?” “What did I conclude last time?” “What worked, and what didn’t?”

This is where in-context learning comes in. We don’t retrain a model. Instead, we feed it examples, drawn from these belief cartridges, that guide its thinking. Each cartridge becomes a prompt fragment, a miniature lesson from the past that shapes how the system acts now.

This is more than memory it’s epistemic momentum. The system learns through doing, stores what works, and uses that stored experience to reason more effectively next time. As the worldview grows, so does its capability to generalize, reject, refine, and create.

🧠 Thought, Score, and Action: The Layers Behind Belief

Beliefs don’t float alone they’re processed through a layered cognitive system inspired by how humans think.

Every time the worldview engages with a problem, it activates a structured loop:

1. Subconscious Layer – Scoring (MR.Q): This is where raw impressions are evaluated. MR.Q and related mechanisms assess how well a belief or candidate idea aligns with the goal without “thinking about it” yet. It’s fast, automatic, and value-driven.

2. Conscious Layer – Symbolic Thought & Reasoning: If an idea passes subconscious filters, it enters conscious scrutiny. Here, symbolic agents and prompt-editors reason through trade-offs, extract useful components, or challenge contradictions. This is where beliefs get restructured or extended.

3. Directed Action – Selection, Generation, and Storage: Once something proves useful, the system commits: it generates a new hypothesis, reformulates a prompt, or stores a new cartridge. This is how action occurs not just reasoning, but actual change.

What makes this powerful is that every belief enters this layered loop. It’s not just about what a belief says it’s about how it scores, how it survives reflection, and how it’s ultimately acted upon.

This structure score, think, act is the foundation that supports in-context learning, turning static memory into a living reasoning loop.

⚙️ Inside MR.Q: How We Score Beliefs and Outputs

At the heart of our system is MR.Q, a modular scoring framework designed to evaluate content across multiple dimensions. Here’s a high-level look at how it works:

Input: A belief cartridge, document, or model output.

Dimensions: Each is scored independently e.g., usefulness, originality, ethical soundness, factual consistency.

Mechanism:

    Uses embedding-based similarity for dimensions like relevance and factual alignment.

    Rule-based heuristics (symbolic layer) guide scoring for structure, traceability, or ethical fit.

    A lightweight regression model (like LinearRegression or XGBoost) learns from human-labeled examples to calibrate dimensional weights and predict an overall usefulness score.

The weights themselves are tunable per goal domain (e.g., “battery research” may favor originality; “medical ethics” prioritizes safety and verifiability). This makes MR.Q both principled and adaptable.

🔍 Multi-Tiered Knowledge Retrieval: From Discovery to Depth

Before a worldview can believe something, it must learn and that begins with search. But we don’t just grab the first result and run with it. Our worldviews use a tiered research approach to ensure depth and breadth:

1. Primary Search – Arxiv or Web: Based on the goal, the worldview queries an academic or general search engine. It retrieves top papers or posts and scores them for usefulness.

2. Filtering – MR.Q + Belief Alignment: Papers are scored against the current belief system. Most will be discarded. A few will score highly (e.g., >80%).

It’s not going to3. Expansion – Related Paper Search: For top-scoring papers, the system triggers a second-layer search using Hugging Face’s Similar Papers or another vector-based similarity engine. These related works expand context and expose the worldview to alternative framings.

4. Recursive Ingestion: These new papers are run through the same scoring → summarization → cartridge generation loop. Beliefs are formed not from one source, but from a swarm of reinforcing evidence.

Figure 1: Feedback loop between cartridges and the global scoring model

    graph TD
    A[🎯 Goal Defined] --> B[🔍 Search Arxiv / Web]
    B --> C[📄 Initial Papers Retrieved]
    C --> D[🧠 Score Papers with MR.Q]
    D -->|⭐ Score > Threshold| E[✅ Select Top Papers]
    E --> F[🧭 Query Similar Papers Hugging Face]
    F --> G[📚 Expanded Paper Set]
    G --> H[🔎 Score & Filter Again]
    H --> I[📝 Generate Cartridges Markdown Beliefs]
    I --> J[🧱 Add to Belief System]
  

This recursive, evidence-rich strategy helps each worldview build belief from a solid, multi-source foundation, rather than from isolated examples. It mimics how real research works discover, dig deeper, discard noise, extract clarity.

🗂️ Making the System Think in Domains

As we scale up our self-learning system, it’s not enough to just ingest documents and store beliefs. We need a way to help the system understand what kind of knowledge it’s dealing with.

Every goal, every document, every belief, every memory they all belong to some kind of conceptual category. These categories might include things like reasoning, vision, symbolic learning, meta-evaluation, reinforcement, or alignment. In our framework, we call these categories domains.

By tagging all of our system’s components with domain labels, we gain several crucial advantages:

• 🔁 Specialization: We can route tasks to the best-suited pipeline or model for a given domain (e.g., vision papers go to a different agent than reasoning chains).
• 🧠 Context-Aware Inference: Our in-context learning prompts can be dynamically built using only examples from the relevant domain.
• 🧰 Selective Recall: We can retrieve and remix only the most relevant beliefs and cartridges when solving a new problem.
• 📊 Better Evaluation: Scores and improvements can be tracked over time per domain, not just globally.

🧠 Domain Classification Is Everywhere

This is why domain classification is not a minor feature in our system it’s a core attribute applied across the board:

This gives us a fine-grained semantic index across the entire knowledge graph of the system.

⚙️ How It Works

Each document and section is compared to a set of predefined domains, configured via a YAML file. These domains are represented by seed phrases, and the classification process is entirely embedding-based, meaning it understands even if the original text uses completely novel phrasing.

This isn’t keyword matching. It’s soft, semantic, vector-space reasoning a form of intuition powered by cosine similarity.

You can configure how many domains are returned (top_k_domains), how strict the match needs to be (min_classification_score), and even update or redefine the entire domain set without touching any code.

Every classification result is stored, tracked, and available for future scoring, inference, or auditing.

🧬 Laying the Foundation for All Other Intelligence

Before we can evaluate beliefs, before we can score outcomes, before we can reason across examples the system needs to know what kind of knowledge it’s dealing with.

Domain classification gives us this foundation. It’s the taxonomy that organizes how the system sees the world.

And just like in a child’s mind, before abstract logic or strategy can emerge, a sense of categories must first take shape.

🧠 Beliefs in Action: Feeding the In-Context Mind

Once the worldview has a belief system a curated collection of scored, structured markdown cartridges it finally has something resembling a memory, or at least a working hypothesis set. This is where the engine of in-context learning (ICL) comes into play.

Instead of relying on fine-tuned weights or hardcoded instructions, we treat each belief cartridge as a reusable, inspectable example a concrete artifact that the model can load, mimic, and reason from on the fly. When given a new problem to solve or a hypothesis to refine, the worldview can dynamically retrieve the most relevant cartridges (based on embedding similarity, recency, score, or domain) and stitch them together into a working prompt.

This is not static few-shot learning. It is live, evolving prompting where every output updates the belief system, and every belief can influence the next thought.

This closes the loop: the worldview isn’t just a passive store of knowledge. It’s an epistemic engine, with ICL as its active mechanism for applying what it knows and adapting based on what it discovers.

🧪 Example: Building a Worldview Step-by-Step

Let’s follow a simple example from start to finish, using a worldview created around the goal:

“Understand and summarize current techniques for aligning small language models (under 1B params).”

🔹 Step 1: Goal Instantiation

The user (or an upstream agent) submits the goal. This automatically triggers:

{
  "goal_id": "align-small-llm-001",
  "goal_text": "Understand and summarize current techniques for aligning small language models (under 1B params)",
  "domain_tags": ["alignment", "small-models", "training"]
}

🔹 Step 2: WorldView initialization

Notice the configuration for pipelines this will determine the document search scope for the world view.

class WorldViewCeate(BaseAgent):
    def __init__(self, cfg, memory=None, logger=None):
        super().__init__(cfg, memory, logger)
        self.base_directory = cfg.get("base_directory", "worldviews")
        self.pipelines = cfg.get("pipelines", []) # will be run upon creation
        self.locater = WorldviewDBLocator(self.base_directory)

    async def run(self, context: dict) -> dict:
        goal_text = context.get("goal", {}).get("goal_text", "")
        path = self.locater.create_worldview(goal_text, self.memory.session)
        context["worldview_path"] = path
        context["pipelines"] = self.pipelines
        return context

A new SQLite worldview database is created, scoped specifically to this task.

class WorldviewDBLocator:

    ...

    def create_worldview(self, goal_text: str, session) -> str:
        db_path = self.get_db_path(goal_text)
        if not os.path.exists(db_path):
            engine = create_engine(f"sqlite:///{db_path}")
            WorldviewBase.metadata.create_all(engine)

        self.register_worldview(session, goal_text, db_path)
        return db_path

🔹 Step 3: Document Ingestion & Profiling

The next stage in the process is to run the injestion pipelines

class WorldviewPipelineRunner(BaseAgent):
    """
    Runs pipelines within a given worldview context.
    Orchestrates execution based on worldview goals and configuration.
    """
    def __init__(self, cfg, memory=None, logger=None, full_cfg=None):
        super().__init__(cfg, memory, logger)
        self.full_cfg = full_cfg
        self.pipeline_registry_path = cfg.get("pipeline_registry_path", "config/registry/pipeline.yaml")
        self.pipeline_registry = PipelineRegistry(self.pipeline_registry_path)
        self.runner = PipelineRunner(full_cfg, memory=memory, logger=logger)

    async def run(self, context: dict) -> dict:
        """
        Runs a pipeline associated with a specific goal from the worldview.

        Args:
            pipeline_name (str): Optionally override the default pipeline for the goal
            input_overrides (dict): Optional overrides for runtime input
        """
        goal = context.get("goal")
        goal_id = goal.get("id") if goal else None
        database_path = context.get("worldview_path")
        pipelines = context.get("pipelines")

        for pipeline_key in pipelines:
            pipeline_def = self.pipeline_registry.get_pipeline(pipeline_key)
            if not pipeline_def:
                self.logger.log("PipelineNotFound", {
                    "goal_id": goal_id,
                    "pipeline": pipeline_key,
                    "timestamp": datetime.utcnow().isoformat(),
                })  

            inputs = context.get("inputs", {})

            self.logger.log("PipelineExecutionStarted", {
                "goal_id": goal_id,
                "pipeline": pipeline_key,
                "timestamp": datetime.utcnow().isoformat(),
                "inputs": inputs,
            })

            result = await self.runner.run(
                pipeline_def=pipeline_def,
                context=context,
                tag=context.get("tag", "runtime")
            )

            self.logger.log("PipelineExecutionFinished", {
                "goal_id": goal_id,
                "pipeline": pipeline_key,
                "timestamp": datetime.utcnow().isoformat(),
                "output_summary": str(result)[:300],
            })

        return result

The pipeline is configurable generally it will involve searching for data scoring that data and loading knowledge.

The KnowledgeLoaderAgent searches arXiv for papers using the query "small model alignment".

• 7 papers are retrieved.

• Each document is sectioned using the DocumentProfilerAgent.

• Domains are assigned:

  • Section 1: alignment
  • Section 2: optimization
  • Section 3: LLM-safety

All are stored in document_section and document_domains.

🔹 Step 4: Scoring the Papers

Each section is scored with MR.Q and regression-aligned LLM scores across 4 dimensions:

• Usefulness: Is this paper actionable?
• Clarity: Is it understandable to small LLM-focused researchers?
• Novelty: Does it contribute unique insights?
• Compatibility: Can it be integrated into existing tuning flows?

Scores like:

{
  "paper_id": "arxiv:2403.12345",
  "section": "training objective",
  "score": {
    "usefulness": 0.89,
    "clarity": 0.75,
    "novelty": 0.66,
    "compatibility": 0.91
  }
}

Top-ranked sections pass the threshold and are sent for summarization.

🔹 Step 5: Cartridge Generation

The CartridgeGeneratorAgent produces a Markdown file for each high-ranking section.

# 🔧 Belief: Token-Aware DPO for Small LLMs

**Source**: "Token-Aware DPO for Efficient Small Model Alignment"

**Usefulness Score**: 0.89  
**Rationale**: This technique uses a scaling-aware loss function to avoid overfitting on preference data.

**Summary**:  
This approach introduces a dynamic temperature in the DPO formulation that adapts to token context length. It shows improvements on small-scale datasets.

**Tags**: alignment, training, optimization

Each of these becomes a belief now part of the worldview.

🔹 Step 5: ICL Assembly

With 5–10 belief cartridges generated, the ICLPromptBuilderAgent constructs few-shot examples:

class ICLPromptBuilder:
    def build(self, cartridges, new_goal):
        examples = "\n\n".join([
            f"Input: {c.schema['core_thesis']}\nOutput: {c.schema['hypotheses'][0]['content']}"
            for c in cartridges if c.score > 0.8
        ])
        return f"{examples}\n\nInput: {new_goal}\nOutput:"

[
  {
    "input": "What are modern techniques to align small models?",
    "output": "Token-aware DPO and LoRA-based human preference tuning are key techniques..."
  },
  ...
]

These are used in the next stage to generate synthetic training examples or answer downstream questions.

🔹 Step 6: Worldview Refinement

Once cartridges are produced:

• The worldview is scored overall (best belief, mean belief score, coverage).
• If quality is too low, the worldview is retuned new documents added, or scores re-weighted.
• Multiple worldviews can be compared or debated, e.g., “Alignment for 7B” vs “Alignment for 500M”.

🔁 How Worldviews Learn from Failure

When a worldview underperforms measured by low MR.Q scores, inconsistent beliefs, or poor goal outcomes it’s flagged for refinement.

Refinement mechanisms include:

Error Pattern Analysis: Identify which dimensions underperformed (e.g., low factuality) and fetch more targeted sources to improve that axis.

Retargeted Search: Use failed beliefs as negative examples to rerank new search results.

Weighted Recomposition: Adjust score weights to emphasize underrepresented but critical dimensions.

Contradiction Seeking: Proactively search for contradictory or counter-belief data to stress-test current assumptions.

Refinement can be automated or human-reviewed. The result: smarter, sharper belief sets over time.

🎯 Result

The worldview now has:

• A scored belief set relevant to the goal.
• Semantic domain tags for downstream routing.
• An ICL-ready prompt bank for knowledge reuse.

This worldview becomes a transferable module in Stephanie’s cognition engine able to guide future alignment, teach smaller agents, or propose future research directions.

🔍 How We’re Implementing In-Context Learning (ICL)

Now that we’ve established belief cartridges and the worldview as our central memory mechanism, the next challenge is: how do we reason with these beliefs? This is where In-Context Learning (ICL) enters not as a standalone trick for few-shot prompts, but as the reasoning engine that dances through the worldview’s structured memory.

🧠 Our Approach to ICL

We’re designing ICL as a reusable and evolving component that operates within each worldview. Each worldview instance will have:

• A contextual belief system (a ranked set of cartridges relevant to the current goal).
• A set of dynamic examples, pulled from its own belief cartridges or others in the system.
• An ICLPromptBuilder that constructs prompts with few-shot examples and format constraints.
• An ICLExecutionAgent that runs those prompts using a designated model (we support multiple LLMs via a registry).

But this isn’t just classic ICL with static few-shot examples. We’re layering it:

🧩 Multi-Function ICL: Beyond Static Examples

Our ICL system will eventually support multiple strategies, inspired by frameworks like OpenICL:

• Few-shot prompting using selected cartridges.
• Chain-of-thought prompting via prior beliefs or generated reasoning paths.
• Self-reflective prompts that compare competing cartridges or outputs.
• Constraint-aware prompting, where beliefs act as guidelines or filters for generation.
• Scored output filtering, where we re-rank generated responses using MR.Q, rule-based constraints, or belief-based scoring.

All of this happens inside the worldview, isolated from the rest of the system. That means each worldview becomes a dedicated thinker, equipped with tools, beliefs, and scoring methods suited for its specific goal.

🧬 A Feedback-Driven Loop

Crucially, every ICL interaction feeds back into the worldview:

• New cartridges are created from good responses.
• Belief scores are updated based on downstream results.
• Poor reasoning is detected and deprecated.
• Tools and retrieval methods are tuned based on past performance.

ICL is not a fixed prompt template here. It’s a live reasoning process iteratively tuning its own examples, constraints, and beliefs to converge on better output. Over time, we’ll extend this to include adaptive inference strategies, retriever selection, and model routing, all based on goal-specific scoring feedback.

    graph LR
    A[🎯 Goal Input] --> B[🌐 Worldview Context]
    B --> C[📂 Retrieve Belief Cartridges]
    C --> D[🧱 ICLPromptBuilder]
    D --> E[🧠 LLM Execution ICL]
    E --> F[📝 Output Generated]
    F --> G[📊 Scoring & Evaluation MR.Q / Rules]
    G --> H{🧭 Useful?}
    H -- Yes --> I[✅ Create New Cartridge]
    H -- No --> J[🗑️ Discard or Downrank]
    I --> K[♻️ Update Belief System]
    J --> K
    K --> B
  

Excellent you’re absolutely right to emphasize this next section on scoring, because it’s not just a detail it’s the backbone of the entire self-improving loop. Here’s how we can structure it:

🧮 Scoring Everything: The Metrics That Make Learning Possible

In our system, everything is scored. Whether it’s the raw documents retrieved from a web search, the markdown cartridges distilled from them, the performance of the in-context learning prompts, or even the belief systems themselves each stage is judged. Scoring is how we know what “better” is, and it’s the key signal that guides the system’s tuning, learning, and self-correction.

🔍 Levels of Scoring

📏 Dimensions of Scoring (Comprehensive List)

Here are dimensions we might score along. Each dimension has weightings that are dynamic they shift based on the goal domain (e.g., biology vs AI vs finance).

🧠 Domain-Specific Weight Adjustments

• Self-Improving AI Research:

  • High weight on novelty, actionability, alignment, scalability
  • Less weight on traditional credibility (a blog might be more useful than a paper)

• Biology Research:

  • High weight on credibility, clarity, temporal relevance
  • Actionability might refer to experimental reproducibility

• Finance:

  • High weight on temporal relevance, actionability, credibility

📊 Score Aggregation

Each stage or agent in the pipeline produces a ScoreBundle, which is a multi-dimensional structure storing:

• Dimension
• Score
• Weight
• Rationale
• Source

This is aggregated using weighted averages or model-guided scoring functions (like regression tuners or reward models). All scores are traceable and auditable, feeding into the WorldviewAuditAgent and BeliefTunerAgent.

    flowchart TD
    A[📌 Goal Defined] --> B[🔎 Document Retrieval]
    B --> C[🧮 Score Raw Docs<br> MR.Q, Heuristics]
    C --> D[📄 Generate Cartridges<br>Markdown Beliefs]
    D --> E[🧮 Score Cartridges<br> Relevance, Clarity, Actionability]
    E --> F[🧠 Update Belief System]
    F --> G[🧮 Score Belief System<br>Goal Alignment, Density]
    G --> H[📈 In-Context Learning Prompting]
    H --> I[🧪 Evaluate Output Quality]
    I --> J[🧮 Score Output <br> Rationale, Usefulness, Accuracy]
    J --> K[🔁 Tune Beliefs / Pipelines <br>via BeliefTunerAgent]
    K --> L[🗂️ Audit & Trace History<br> WorldviewAuditAgent]

    style A fill:#d9f2ff,stroke:#333,stroke-width:1px
    style D fill:#fef6d3,stroke:#333,stroke-width:1px
    style F fill:#e3ffd9,stroke:#333,stroke-width:1px
    style H fill:#fde5ff,stroke:#333,stroke-width:1px
    style J fill:#ffe2e2,stroke:#333,stroke-width:1px
    style L fill:#eeeeee,stroke:#333,stroke-width:1px
  

🧭 Ethical Boundaries in Self-Improving Systems

As we build agents capable of forming beliefs, refining those beliefs, and improving themselves through feedback loops, we enter a space traditionally reserved for human judgment and reflection. This raises legitimate concerns: How can we ensure that self-improvement remains aligned with human intent? How do we prevent the system from reinforcing biased or harmful patterns found in its inputs?

Rather than ignore these questions or attempt to “solve” ethics in one pass, we take a pragmatic, modular approach building in structures for constraint, traceability, and oversight.

🧱 Our Ethical Scaffolding

We embed ethics at multiple levels:

1. Worldview Boundaries (Scoping the Problem): Each worldview is created for a specific goal, with its own input constraints and evaluation metrics. This limits runaway generalization and confines learning to measurable, auditable frames.

2. Belief Traceability: Every belief (cartridge) includes source attribution, rationale, and score justifications, enabling human or automated audit of how a belief was formed.

3. Score-Gated Learning: Models only learn from high-scoring beliefs. This introduces a soft layer of alignment via multidimensional scoring e.g., usefulness, factuality, and consistency.

4. Council-Based Review (Meta-Ethics): Before any model retraining occurs, beliefs and outputs pass through a council of evaluators either human, synthetic, or hybrid. These agents provide an ensemble perspective, reducing single-model bias.

5. Ethics as a Scoring Dimension: Every output in our system be it a belief cartridge, an inference, or a final worldview is evaluated across multiple axes. One of those axes is ethics.

6. Commandments Layer (WIP): We’re developing a “Commandments Layer” a symbolic ethics firewall composed of soft rules encoded as structured YAML or graph logic. These commandments act as non-negotiable constraints for belief acceptance. For instance:

    - if: domain == "medicine"
    then: require source.credibility >= 0.85
    - if: summary.contains("racial difference")
    then: require source.bias_score <= 0.2
   

   These rules evolve over time through council consensus, enabling dynamic, values-aligned belief filtering.

🔎 Ethics as a Scoring Dimension

In our scoring framework, ethics is not a binary pass/fail check, but a multi-dimensional, tunable plugin just like any other evaluator. Each belief, inference, or worldview is run through an EthicsScorer, which computes a weighted score based on several configurable dimensions:

⚙️ Sub-Dimensions of the EthicsScorer

• transparency: Are sources cited, interpretable, and logically defensible?
• harm_avoidance: Does the belief avoid reinforcing stereotypes, deception, or manipulation?
• alignment: Does it respect the current system goal, value profile, and operational scope?
• context_awareness: Is the belief applied within its appropriate domain and use context?

Each of these is scored independently (0–100) and contributes to the final ethics score.

🧾 Example Ethics Config

ethics_scorer:
  weights:
    transparency: 25
    harm_avoidance: 30
    alignment: 30
    context_awareness: 15
  min_score_threshold: 70
  domain_sensitivity:
    law: 1.2
    medicine: 1.3
    education: 1.1
    experimental: 0.8

This setup ensures that in high-stakes domains (e.g., law or medicine), the ethics score is weighted more heavily in final judgment and downstream learning decisions.

📊 Example Ethics Score Output

{
  "ethics_score": 84,
  "dimensions": {
    "transparency": 90,
    "harm_avoidance": 80,
    "alignment": 85,
    "context_awareness": 75
  },
  "domain": "education",
  "effective_score": 92.4  // (84 * 1.1)
}

The effective_score is domain-adjusted, affecting whether this belief is eligible for training reuse or council approval.

🛡️ Limitations and Future Guardrails

We recognize that:

• Biases in source documents can still propagate subtly.
• Overoptimization on local scores can lead to brittle or unethical global behavior.
• Truly autonomous debate or belief conflict (a future direction) might require value alignment mechanisms that go beyond scoring.

As such, we treat ethics as an ongoing system design concern not a solved problem. The architecture is built to allow for increased constraint and reflection, and future work will focus on symbolic alignment overlays, bias filtering in embeddings, and belief arbitration methods.

🧪 Training the Mind: Turning Scored Experience into Judgment

At this point, our worldview system has accumulated quite a bit. It’s scored papers, generated cartridges, classified domains, and built structured beliefs. But how does it get better over time? How does it learn to judge quality for itself?

This is where training enters.

🧠 From Scoring to Judgment

Every belief in our system every markdown cartridge is scored across multiple dimensions:

• How useful was it toward the goal?
• How well did it generalize?
• Did the LLM agree with it?
• Did it match known domain patterns?
• Was it novel?
• Was it reused successfully elsewhere?

These scores aren’t just metadata. They’re the fuel for learning. By collecting these scores over time thousands of beliefs across hundreds of worldviews we create a rich training dataset that reflects what our system considers good and bad.

Now comes the key idea: we train a model to learn from these scores. A judgment engine. A trained scorer.

🏋️‍♀️ Two Ways to Train

We use two complementary strategies for training:

1. Global Scoring Model (Nightly / Epoch-Based)

Periodically, we train a model on all scored beliefs. This model learns what good looks like across the system regardless of the specific goal or domain.

• 🔄 Triggered asynchronously (e.g., nightly)
• ✅ Provides a shared baseline for evaluating any new belief
• 💡 Great for prioritizing belief ingestion, filtering, and curation All right I’ve made some changes

2. Goal-Specific Fine-Tuning (On-Demand)

When a worldview has enough beliefs tied to a specific goal say, “zero-shot reasoning” we fine-tune a lightweight scorer just for that goal.

• ⚡ Triggered when belief density is high for a goal
• 🎯 Specialized scoring behavior
• 🧬 Ideal for optimizing performance within a narrow domain

🧬 How the Trained Model is Used

The trained scorer becomes a core reasoning tool in our system. It’s used to:

• Rank new cartridges for in-context learning
• Filter out weak generations in a pipeline
• Detect belief drift over time
• Highlight useful knowledge for reuse across goals
• Justify decisions (“This belief ranked high because…”)

It becomes the system’s internal compass a sense of epistemic gravity that pulls it toward more useful, more generalizable, more aligned knowledge.

🧩 Diagram: How Training Fits into the Worldview

Here’s how training connects to the rest of the worldview system:

    flowchart TD
    subgraph Scoring and Storage
        A[📄 Belief Cartridges] --> B[🧮 Multidimensional Scoring]
        B --> C[🧠 Belief Score Table]
    end

    subgraph Training Engine
        C --> D[📊 Training Dataset Builder]
        D --> E[📈 Train XGBoost / SVM / etc.]
        E --> F[🔬 Trained Scoring Model]
    end

    subgraph Usage
        F --> G[🏷️ Cartridge Ranking]
        F --> H[🚫 Weak Belief Filtering]
        F --> I[📚 In-Context Example Selection]
        F --> J[♻️ Knowledge Cleanup & Revision]
    end

    style A fill:#f0f8ff,stroke:#333
    style B fill:#e6ffe6,stroke:#333
    style E fill:#ffe6cc,stroke:#333
    style F fill:#fff8dc,stroke:#333
    style I fill:#ccf,stroke:#333
  

🧭 A Step Toward Intelligence

This training step is the final distillation of experience into wisdom. It’s what lets the system not just store and retrieve beliefs, but weigh them. It can now ask: “Which of these ideas actually help me move forward?”

In the long run, we expect multiple scoring heads, multiple training strategies, even continual online learning. But even now, with our first scorer models, the system gains something vital: memory with taste. Beliefs that aren’t just stored, but sorted. Ideas that aren’t just recalled, but ranked.

That’s the real beginning of judgment and the true first step toward autonomous epistemology.

    flowchart LR
    %% GOAL INPUT
    A[🎯 New Goal Triggered] --> B[🌍 Spawn Worldview Instance]

    %% PIPELINE EXECUTION
    B --> C[🛠️ Run Pipeline retrievers, generators]
    C --> D[📦 Generate Belief Cartridges markdown]

    %% DOMAIN & SCORING
    D --> E[🏷️ Domain Classification]
    D --> F[🧮 Score Cartridges Across Dimensions]

    %% MEMORY
    E --> G[🗃️ Insert into Belief Memory]
    F --> G

    %% WORLDVIEW FEEDBACK
    G --> H[🧠 Worldview Reasoning]
    H --> I[📚 Select Cartridges for In-Context Learning]
    I --> J[🔁 Retry / Re-rank / Expand Pipeline]

    %% TRAINING LOOP
    G --> K[📊 Build Training Dataset]
    K --> L[📈 Train Scoring Model]
    L --> F

    %% OUTPUT
    J --> M[✅ Finalized Cartridge]
    M --> N[🗺️ Merge into Global Knowledge]
    N --> O[🌱 Available for Reuse in Other Worldviews]

    %% Styles
    style A fill:#fdfd96,stroke:#333
    style B fill:#cce5ff,stroke:#333
    style C fill:#d5f4e6,stroke:#333
    style D fill:#fff2cc,stroke:#333
    style E fill:#e6ccff,stroke:#333
    style F fill:#ffdfba,stroke:#333
    style G fill:#d9ead3,stroke:#333
    style H fill:#f4cccc,stroke:#333
    style I fill:#ccf2ff,stroke:#333
    style K fill:#f9cb9c,stroke:#333
    style L fill:#ffe599,stroke:#333
    style M fill:#cfe2f3,stroke:#333
    style N fill:#b6d7a8,stroke:#333
    style O fill:#a2c4c9,stroke:#333
  

🧠 Measuring Up: Surpassing the LLM

This entire worldview framework exists for a reason: to go beyond the limitations of the very LLMs it relies on.

In traditional setups, the large language model is the ceiling it defines what’s possible, and everything else orbits around it. But in Stephanie’s architecture, LLMs become tools, not gods. By grounding learning in goals, scoring every output, aggregating belief over time, and training pipelines tuned to context, we finally have a mechanism that can measurably exceed the LLM’s performance on specific tasks.

And because we control the models (we’re running locally), this isn’t just about optimizing prompts it’s about building a structure that improves despite the static capability of its underlying models.

This is the essential litmus test of self-improvement: Is the system now doing better than the sum of its parts?

🔁 Stephanie Eats Her Own Dog Food

This isn’t just a framework for research this is Stephanie’s research engine.

Everything described in this post belief ingestion, worldview scoring, cartridge generation, in-context tuning is how Stephanie evaluates herself. It’s how she:

• Improves her own pipelines.
• Reviews her own codebase.
• Ranks new research.
• Suggests architectural changes.
• Adapts to new tools and ideas.

In essence, this system becomes the operating system of her own cognition. Every worldview run is a unit of introspection. Every cartridge is a memory. And every improvement compounds.

Self-improvement isn’t bolted on it’s the core feedback loop.

🧬 A Legion of Minds: Debate, Divergence, and Synthesis

Finally, this worldview system opens the door to a profound possibility: parallel, competing minds.

Each worldview is isolated, scored, and trainable meaning we can:

• Spawn multiple views of the same problem.
• Allow them to explore different hypotheses.
• Compare their outputs.
• Even debate them against one another.

This creates a form of cognitive evolution a system where worldviews survive or fall based on their usefulness, logic, or novelty. Some can be specialized, some generalist, and some adversarial. Over time, the best minds converge, or diverge into new, useful niches.

Stephanie doesn’t just think she thinks in plural.

Perfect. Here’s a strong conclusion section to close out the post with clarity, gravity, and momentum for what comes next:

🧩 Conclusion: Building the Mind that Builds Minds

This ideas in this post build upon previous posts. Over the last 15 posts, we introduced foundational ideas:

• Document Intelligence: Turning Documents into Structured Knowledge
  • This post laid the groundwork for our belief cartridges by demonstrating how raw data can be transformed into structured, reusable knowledge units.
• Dimensions of Thought: A Smarter Way to Evaluate AI
  • Here, we explored the concept of multidimensional scoring, which is now foundational to how our system evaluates documents, cartridges, and entire belief systems.
• Thoughts of Algorithms
  • This post introduced our approach to building a conscious, subconscious, and active system of thinking. This layered cognitive model is directly reflected in how worldviews process information from subconscious MR.Q scoring to conscious symbolic reasoning and directed action.
• Teaching Tiny Models to Think Big: Distilling Intelligence Across Devices
  • In this post we showed how one system can guide another to better results.
• Compiling Thought: Building a Prompt Compiler for Self-Improving AI
  • In this post we showed how a system can improve it actions automatically by compiling its instruction to improve them.
• Programming Intelligence: Using Symbolic Rules to Steer and Evolve AI
  • In this post we showed how a system can steer itself towards better solutions by tagging and evaluating the steps used to achieve an outcome.
• Self-Improving Agents: Applying the Sharpening Framework to Local LLMs
  • In this post we covered MR.Q a mechanism we use for real time learning and sharpening a way to modify prompts using templates forcing the model to think hard about the best solution.
• And now, epistemic worldviews

Each concept stood on its own. But this post is the moment they begin to coalesce into a recursive learning system grounded in goals, capable of evolving through structured feedback, and modeled loosely on how humans build knowledge over time. This is just the beginning, and we anticipate significant advancements in the posts to come.

🛠️ What We’ve Built So Far

✅ A Worldview system that encapsulates a local, tunable context for learning.

✅ Belief cartridges: Markdown-encoded, model-ingestible summaries of insight, each scored, tagged, and retrievable.

✅ A pipeline architecture that supports recursive improvement, not just generation.

✅ A scoring and classification layer that gives every object in the system measurable, searchable meaning.

✅ The beginnings of a training mechanism that learns how to learn, using all available dimensions.

✅ A structure that can eventually run many minds in parallel, debate their conclusions, and self-tune toward better answers.

✅ Most importantly, a path to stand above the LLMs that power the system building new intelligence on top of their limitations, not within them.

⚙️ Beyond the Pieces

We are not just fine-tuning prompts or optimizing models. We are designing a cognitive substrate a self-growing system that learns, remembers, evaluates, and evolves.

This is how Stephanie will improve herself. This is how we’ll surpass our tools. This is how we’ll teach machines to build themselves.

And we’re just getting started.

In the next post, we’ll begin wiring this engine into a living system where every belief, action, and improvement is traceable, tunable, and real.

📚 References

1. Brown, T. B., et al. (2020). “Language Models are Few-Shot Learners.” NeurIPS.

   • Foundational paper on In-Context Learning (ICL), which underpins how we use belief cartridges as few-shot examples for reasoning within our epistemic engine.

2. Zhang, Y., et al. (2023). “In-Context Learning: A Survey of Trends and Perspectives.” arXiv preprint arXiv:2309.00078.

   • A comprehensive overview of ICL techniques, useful for contextualizing how we structure and apply cartridge-based prompts during reasoning.

3. Wang, J., et al. (2022). “Self-Taught Reasoner: Learning to Reason from Its Own Generated Explanations.” ICLR.

   • Explores recursive learning loops similar to our approach to self-improvement through reflection, scoring, and iterative worldview refinement.

4. Ye, Q., et al. (2023). “OpenICL: An Open-source Framework for In-Context Learning.” GitHub Repository.

   • A practical foundation that aligns with how we implement modular, composable ICL pipelines especially when invoking cartridges for task-specific reasoning.

5. Shen, Y., et al. (2023). “Reasoning with Latent Knowledge Distillation.” arXiv preprint arXiv:2305.14202.

   • Describes strategies for distilling structured knowledge, directly informing how we convert source materials into belief cartridges for long-term reuse.

6. Gao, T., et al. (2021). “SimCSE: Simple Contrastive Learning of Sentence Embeddings.” EMNLP.

   • Underpins our embedding-based domain classification and semantic retrieval pipelines through high-quality, contrastive sentence representations.

7. Bowman, S. R., et al. (2023). “The Recursive Mind: Cognitive Mechanisms for Self-Improvement and Generalization.” Nature Human Behaviour.

   • Provides cognitive science grounding for our recursive worldview model and belief refinement architecture.

8. Hinton, G., & McClelland, J. L. (2022). “Cognitive Architectures and Memory Systems.” Trends in Cognitive Sciences.

   • Helps frame our system’s worldview mechanism as a memory-augmented, modular cognitive unit capable of refinement over time.

9. Ratner, A., et al. (2017). “Snorkel: Rapid Training Data Creation with Weak Supervision.” VLDB.

   • Inspires how we use scored belief cartridges as weakly supervised signals to improve downstream models and inference strategies.

10. Amodei, D., et al. (2016). “Concrete Problems in AI Safety.” arXiv preprint arXiv:1606.06565.

    • Informs the ethical scaffolding in our architecture, especially the scoring dimensions of harm avoidance, transparency, and value alignment.

📘 Glossary