Models From First Principles on AIBussin — AI applications, systems and books

From Vectors to Symbols — The Binding Problem Inside Neural Networks

Sat, 05 Sep 2026 18:54:00 +0100

From Vectors to Symbols — The Binding Problem Inside Neural Networks

The previous chapter changed our scale of analysis.

We stopped asking only what architecture a model had and started asking where the computation lived.

Was capability coming from new parameters?

More recurrent steps?

More sampled trajectories?

A selector?

A verifier?

Different post-training?

That wider view exposed a second question.

Suppose the computation works.

Suppose a neural network solves arithmetic, manipulates code, follows grammatical structure, or reasons over logical relations.

Reasoning Is More Than Architecture — Where Extra Computation Lives

Tue, 01 Sep 2026 10:41:00 +0100

Reasoning Is More Than Architecture — Where Extra Computation Lives

So far in Models From First Principles, we have changed several different things and called all of them model design.

We changed what a model predicts.

MR.Q produced one learned quality score.

EBT added Q, V, policy, and advantage.

SICQL turned those outputs into explicit model components.

Then we changed how computation unfolds.

HRM introduced recurrent state operating at different timescales.

Preference Rankers — Learning Which Answer Is Better

Sat, 22 Aug 2026 01:18:00 +0100

Preference Rankers — Learning Which Answer Is Better

So far in Models From First Principles, we have mostly trained models by telling them what the answer should be.

MR.Q took a context and a response and produced a number:

context + response
 ↓
 model
 ↓
 0.82

That number might mean quality.

Or usefulness.

Or reward.

But there is an awkward question hiding underneath that architecture:

Where did the 0.82 come from?

Which Model Should You Use? MR.Q, EBT, SICQL, HRM, Tiny and PACS Compared

Sat, 08 Aug 2026 15:11:00 +0100

Which Model Should You Use? MR.Q, EBT, SICQL, HRM, Tiny and PACS Compared

This is the final post in Models From First Principles.

The earlier posts asked a sequence of architectural questions:

how do we score a context-response pair?
when is one scalar no longer enough?
when should Q, V and policy become explicit components?
when is one forward pass insufficient?
when does recurrence help?
when does hierarchy help?
when is a smaller recursive model a better trade-off?
when should attention or a sparse autoencoder be added?
when should we change the optimizer rather than the model?

This post asks the question that matters when building a real system:

PACS — Building an Optimizer From Gradient Statistics

Sat, 08 Aug 2026 15:05:00 +0100

PACS — Building an Optimizer From Gradient Statistics

So far in Models From First Principles, every post has asked some version of the same question:

What should the model compute?

MR.Q gave us a scalar quality estimate.

EBT split one shared representation into Q, V and Policy.

SICQL made those heads explicit, replaceable components.

HRM introduced repeated computation over fast and slow latent states.

Tiny compressed iterative refinement into one recursive latent state.

Inside Tiny — Residual Blocks, Attention and Sparse Autoencoders

Sat, 08 Aug 2026 15:00:00 +0100

Inside Tiny: Residual Blocks, Attention and Sparse Autoencoders

In the previous post, we built a compact recursive model around one idea:

context + candidate + latent state
 ↓
 projection
 ↓
 reusable core
 ↓
 proposed update
 ↓
 z ← z + α · update
 ↓
 repeat

That architecture looked more sophisticated than MR.Q, EBT or SICQL because it introduced recurrence.

But the central idea of this series is that a model stops looking mysterious when we keep opening it.

Tiny — Recursive Reasoning With a Small Neural Network

Sat, 08 Aug 2026 14:55:00 +0100

Tiny — Recursive Reasoning With a Small Neural Network

The previous post introduced a much more ambitious architecture.

Instead of taking one representation and predicting from it once, the Hierarchical Reasoning Model repeatedly updated two latent states:

input
 ↓
low-level state
 ↓ ↓ ↓
high-level state
 ↓
repeat

That gave us something genuinely new:

computation could continue without adding a new set of parameters for every step.

HRM — Hierarchical Reasoning With Fast and Slow Recurrent State

Sat, 08 Aug 2026 14:48:00 +0100

HRM — Hierarchical Reasoning With Fast and Slow Recurrent State

The previous models in this series were mostly one-pass models.

MR.Q took two embeddings and produced one score.

EBT kept the same basic structure but added several heads.

SICQL made those heads explicit components.

The architecture grew, but the shape of the computation was still familiar:

input
 ↓
encoder
 ↓
representation
 ↓
heads
 ↓
outputs

HRM changes the question.

SICQL — Building a Model From Q, V and Policy Networks

Sat, 08 Aug 2026 14:44:00 +0100

SICQL — Building a Model From Q, V and Policy Networks

In the previous post we took the MR.Q idea and expanded it into something richer.

Instead of asking one question of a shared representation, EBT asked several:

How good is this state-action pair? -> Q
How good is the state more generally? -> V
What action should be preferred? -> Policy
How much better is Q than V? -> Advantage

That already gave us a more expressive system.

EBT — From One Score to Q, V, Policy and Advantage

Sat, 08 Aug 2026 14:39:00 +0100

EBT — From One Score to Q, V, Policy and Advantage

In the previous post we built MR.Q: a small model that takes a context embedding and a response embedding, combines them, and predicts one scalar.

That architecture is useful because it is brutally simple:

context embedding
 +
response embedding
 ↓
 encoder
 ↓
 representation z
 ↓
 predictor
 ↓
 Q value

But one scalar eventually becomes restrictive.

MR.Q — Building a Neural Quality Model From Two Embeddings

Sat, 08 Aug 2026 14:33:00 +0100

MR.Q — Building a Neural Quality Model From Two Embeddings

In the previous post, we established the core idea behind this series:

A complicated model becomes understandable when you recursively decompose it into smaller models, blocks, layers and tensor operations.

Now we build the first real model.

Not a transformer.

Not a giant language model.

Not an agent.

A scorer.

We will take two embeddings:

context embedding
response embedding

combine them, encode the relationship between them, and predict one scalar:

The Model Inside the Model

Sat, 08 Aug 2026 14:27:00 +0100

The Model Inside the Model

This is the first post in Models From First Principles.

The previous PyTorch From First Principles series worked from the bottom up.

We started with tensors.

Then gradients.

Then nn.Module.

Then data pipelines, convolution, attention, debugging, performance and finally a small GPT-style language model built from scratch.

That series answered:

What are the pieces?

This series asks a different question:

What happens when we start composing those pieces into increasingly sophisticated models?

Mon, 01 Jan 0001 00:00:00 +0000

Models From First Principles — Working Ledger

Book intention

Understand modern AI models by opening the abstractions and building the mechanisms in layers, while keeping the mathematics, architecture, optimization, inference, training, and working code connected.

The review question is not merely whether each chapter is well written. It is whether each chapter does the job it is supposed to do at this point in the sequence and whether the sequence leaves a useful model or mechanism missing.