Routing on AIBussin — AI applications, systems and books

The Memory Nexus

Sat, 19 Sep 2026 05:00:06 +0100

Chapters 3 through 5 leave the system with an embarrassment of options. Chapter 3 built hybrid retrieval over raw history with reranking. Chapter 4 added a persistent derived graph with several query modes. Chapter 5 added cue-conditioned associative propagation over that graph. Each chapter earned its mechanism conditionally, and each left the cheaper layers available underneath. The question none of them answers is the one a deployed system meets first:

One Runtime, Many Windows

Mon, 14 Sep 2026 05:00:09 +0100

Part 2 — Get the Model Out of the Chat Box

A chat window is an interface with a person inside the loop doing the integration. This part takes the process out of it and gives the work somewhere else to live.

That happens in stages. The work needs a durable identity and a record that survives the interface closing. The model underneath has to be replaceable, because it will be replaced. A model call has to become a recorded process event rather than a string. That call then has to survive a change of provider dialect, its usage numbers have to mean something before anyone does arithmetic on them, and finally a successful call has to stop being mistaken for finished work.

From Measurements to Policy

Sun, 30 Aug 2026 18:37:00 +0100

Chapter 11 ended with a typed reliability record.

It might say:

containment          = PASS
relation_fidelity    = PASS
sensitivity          = PASS
epistemic_adequacy   = ANSWERABLE
provenance           = UNVERIFIED

That record describes the candidate.

It still does not authorize the candidate.

To make the distinction concrete, we built a deliberately flawed reference policy that checked containment, structural fidelity, and answerability but forgot to require verified provenance for a high-risk action.

Running the same immutable record through two policy versions produced:

What Should Happen Next?

Mon, 14 Sep 2026 05:00:28 +0100

Part 6 — Put Intelligence Into the Process

The pieces are all built. This part puts them under one policy and then joins them.

It starts with the decision that usually gets skipped: which operation does the process need next — a model call, a deterministic check, a person, or a stop? That choice comes before any question about which model, and this part measures what climbing from cheap to expensive actually bought. Then one task runs through every boundary the book has built, from intent and authority to effect, verification and acceptance, to find out whether mechanisms that each work alone still hold where they hand off to one another.

The Decision Router

Thu, 08 Oct 2026 09:00:00 +0100

The Decision Router

This chapter is a simulation over assumed provider profiles. The provider accuracy-by-difficulty curves, costs and signal correlation are assumed and swept; every number is a consequence of them. No real router (RouteLLM, Hybrid LLM) is measured. The assumptions sit next to the results.

The problem

Chapter 28 ended with a table mostly full of NOT_OBSERVED. A router makes that honest gap useful: it chooses, per request, the cheapest provider that is competent for that request, so quality comes from where it is measured and cost is saved elsewhere. This chapter asks: can a router choose the cheapest competent provider for each request?

Advanced Agents From First Principles 17: What Is Your Agent Actually Uncertain About?

Sun, 09 Aug 2026 11:02:00 +0100

What Is Your Agent Actually Uncertain About?

An agent reaches a difficult point in a task.

It is not sure what to do next.

A common implementation responds like this:

uncertain
   ↓
call the model again
   ↓
still uncertain
   ↓
call a stronger model
   ↓
still uncertain
   ↓
search more

That is not a reasoning strategy.

It is a spending strategy.

The system is using more computation without identifying what information is actually missing.

Advanced Agents From First Principles 15: How Do You Optimize an Agent Policy Without Turning It Into Another Black Box?

Sun, 09 Aug 2026 10:49:00 +0100

How Do You Optimize an Agent Policy Without Turning It Into Another Black Box?

By now our advanced agent can do a lot.

It can:

route tasks to different models or specialists,
decide whether to search,
choose a search budget,
decide when to escalate,
invoke critics,
retry or recover,
stop when evidence is strong enough,
learn from verified production trajectories,
and trace the decisions that produced each outcome.

That creates a new problem.

Advanced Agents From First Principles 14: Can Your Agent Learn From Its Own Trajectories Without Learning the Wrong Lessons?

Sun, 09 Aug 2026 10:33:00 +0100

An advanced agent now leaves behind something extremely valuable:

evidence.

Not merely chat history.

Not merely model outputs.

Not merely traces.

A sufficiently instrumented system can record:

what state it was in,
what alternatives it considered,
which route it selected,
what branches it pruned,
which model or specialist it escalated to,
which tools it called,
which critic changed the answer,
what verification evidence was produced,
how much compute was spent,
and whether the final result actually passed.

That immediately suggests a tempting idea:

Advanced Agents From First Principles 10: Are You Combining Every Agent Technique Into One Monster? Build a Mixture-of-Agents Runtime

Sun, 09 Aug 2026 00:25:00 +0100

You have a working agent.

Then you add retrieval.

Then memory.

Then Best-of-N.

Then critique and revision.

Then Tree of Thoughts.

Then MCTS.

Then specialist models.

Then adversarial review.

Then a planner, executor, critic and verifier.

Then a stronger model for hard cases.

Eventually the architecture starts to look like this:

request
  ↓
planner
  ↓
retrieval
  ↓
reasoning
  ↓
Best-of-N
  ↓
critic
  ↓
Tree of Thoughts
  ↓
MCTS
  ↓
frontier model
  ↓
second critic
  ↓
verifier

Every mechanism may have been individually reasonable.

The Space Between Models Has Holes: Mapping the AI Gap

Wed, 22 Oct 2025 20:30:36 +0100

🌌 Summary

What if the most valuable insights in AI evaluation aren’t in model agreements, but in systematic disagreements?

This post reveals that the “gap” between large and small reasoning models contains structured, measurable intelligence about how different architectures reason. We demonstrate how to transform model disagreements from a problem into a solution, using the space between models to make tiny networks behave more like their heavyweight counterparts.

We start by assembling a high-quality corpus (10k–50k conversation turns), score it with a local LLM to create targets, and train both HRM and Tiny models under identical conditions. Then we run fresh documents through both models, collecting not just final scores but rich auxiliary signals (uncertainty, consistency, OOD detection, etc.) and visualize what these signals reveal.