Repository navigation
Educators
Quick Scan
For: Educators, parents, researchers, curious minds
Time to first insight: 8 minutes
Prerequisites: None (technical depth provided where relevant)
What you'll understand: Why self-correcting systems matter and how Compitum builds them
Note for Researchers: This introduction emphasizes pedagogical principles over mathematical formalism. For rigorous treatment, see our technical documentation. What follows is an existence proof that complex systems can be explained without sacrificing conceptual precision.
Maria Montessori designed her materials with something she called control of error – the ability for a child to know, without being told, whether they've gotten it right or wrong.
Consider the Pink Tower: ten pink cubes that decrease in size from 10cm to 1cm per side. When a child stacks them incorrectly, the tower itself shows them the error. The materials provide immediate, honest feedback. The child doesn't need a teacher hovering, correcting, praising, or punishing. The material itself teaches.
This is revolutionary pedagogy because it implements what machine learning researchers would later call self-supervised learning with intrinsic rewards. The child develops:
- Independence: Learning without external supervision signals
- Self-correction: Online error detection and correction
- Internal standards: Learned value functions aligned with task structure
- Persistence: Sample-efficient exploration through low-cost failure
The Montessori method anticipated core principles of reinforcement learning and active learning by nearly a century. Control of error is not sentiment—it's a design pattern for building systems that learn autonomously from structured interaction with their environment.
Now, consider how we currently route queries to different AI models.
Someone asks a question. A system guesses which AI should answer – maybe a fast one, maybe a powerful one, maybe a specialized one. It makes this guess based on... well, often very simple rules. "If the question mentions code, use the coding model." "If it's short, use the fast model."
There is no Pink Tower. The system doesn't know if it made a good choice. It has no control of error. It can't learn from mistakes because it can't see them.
State-of-the-art routing systems typically rely on:
- Heuristic rule sets (brittle, non-adaptive)
- Supervised classifiers trained on labeled routing decisions (expensive labels, distribution shift)
- Reward models that require human preference data at scale (annotation cost, label noise)
What's missing is closed-loop learning from natural system feedback. Current systems optimize for proxy metrics while remaining blind to the actual objective: did this routing decision produce good outcomes?
This is like telling a child "stack these blocks" and then never letting them see whether the tower stands or falls. The learning loop is broken.
Compitum builds a Pink Tower for AI routing systems. More precisely, it implements a self-correcting routing policy with online metric adaptation.
When Compitum routes a query to a model, it:
- Makes predictions about how well each model will perform (calibrated uncertainty quantification)
- Tracks what actually happens (observes realized quality, latency, cost)
- Measures the error between prediction and reality (prediction error as learning signal)
- Adjusts its internal understanding based on that error (online Riemannian metric learning)
- Gets better over time without manual retraining (continual learning with stability guarantees)
The system develops its own internal sense of which models work well for which types of questions—not through expensive human labels, but through intrinsic task feedback. Just like that child with the Pink Tower.
graph LR
A[Query] --> B[Predict Utility]
B --> C[Route to Model]
C --> D[Observe Outcome]
D --> E[Measure Error]
E --> F[Update Metric]
F --> B
style B fill:#e3f2fd
style E fill:#fff3e0
style F fill:#e8f5e9
style C fill:#fce4ec
Figure 1: The closed learning loop. Predictions generate routing decisions, observations generate errors, errors drive metric updates.
The key insight: By embedding queries in a learned Riemannian manifold and using Lyapunov-based control for stable updates, we achieve what supervised approaches cannot—continuous adaptation to shifting query distributions without catastrophic forgetting or reward hacking.
Montessori didn't just randomly design cubes. She understood principles of perception, measurement, and graduated difficulty. Similarly, Compitum doesn't just randomly assign models. It uses several mathematical materials that work together:
What it is: A learned Riemannian metric tensor that defines distances in query space
Why it matters: Euclidean distance fails for high-dimensional semantic spaces—we need geometry that respects the problem structure
The pedagogy: The system learns which queries are truly similar (not just which ones look similar in raw feature space)
The theory: Adapts via online gradient descent on a low-rank + diagonal parameterization, maintaining positive-definiteness through Cholesky factorization
What it is: A symbolic free energy functional balancing quality, speed, cost, distance, and epistemic uncertainty
Why it matters: Real decisions always involve multi-objective trade-offs under uncertainty
The pedagogy: Like teaching a child that "fastest" isn't always "best," the system learns nuanced decision-making
The theory: Differentiable utility function enabling gradient-based optimization with calibrated uncertainty propagation
What it is: Hard convex constraints (privacy, regional restrictions, safety limits) enforced via reflective constraint solving
Why it matters: Some boundaries aren't negotiable—they're system requirements
The pedagogy: Freedom within limits – another Montessori principle
The theory: Polytope feasibility checking with shadow price computation for sensitivity analysis
What it is: Kernel density estimation over past successful routing decisions in whitened coordinate space
Why it matters: Past success predicts future success; anomaly detection prevents catastrophic decisions
The pedagogy: Building on prior knowledge, not starting from zero each time
The theory: Weighted reservoir sampling with Scott's rule bandwidth selection for non-parametric density estimation
What it is: Entropy-based detection of decision boundaries where multiple models have similar utility
Why it matters: Confidence without competence is dangerous; uncertainty awareness enables safe exploration
The pedagogy: Metacognition – knowing what you know and what you don't
The theory: Softmax entropy over model utilities combined with predictive uncertainty from calibrated regressors
What it is: Lyapunov-based trust region controller preventing instability during metric updates
Why it matters: Online learning without stability guarantees leads to divergence
The pedagogy: Like learning to ride a bike – small adjustments, not wild overcorrections
The theory: Quadratic Lyapunov function with integral control term and adaptive step size clipping to ensure convergence
graph TD
Q[Query Features] --> M[Metric Distance]
Q --> P[Predictors]
M --> E[Free Energy]
P --> E
E --> C[Constraints]
C --> S[Selected Model]
S --> B[Boundary Check]
B --> U[Controller Update]
U --> M
style M fill:#e3f2fd
style E fill:#fff3e0
style C fill:#fce4ec
style U fill:#e8f5e9
Figure 2: Component interaction. Each mathematical material serves a specific role in the learning loop.
Silicon Valley has a problem: it often treats users like beta testers and treats learning like optimization. But educators know that learning is not the same as optimizing.
Learning requires:
- Error visibility: The learner must see their mistakes (observability)
- Safe failure: Mistakes must be low-stakes enough to learn from (bounded regret)
- Graduated complexity: Start simple, increase difficulty progressively (curriculum learning)
- Internal motivation: The drive must come from within (intrinsic rewards)
- Time and patience: Real understanding takes time (sample efficiency vs. asymptotic performance)
Montessori understood this in 1907. Modern machine learning is still working through these principles in 2025.
The broader insight: Many contemporary ML challenges—reward hacking, distribution shift, catastrophic forgetting, exploration-exploitation trade-offs—have analogs in educational psychology. Pedagogical principles like control of error are not metaphors for technical concepts; they are technical concepts, formulated in a different language by practitioners solving similar problems in a different domain.
Compitum embodies these principles:
- It sees its errors (observable prediction errors as learning signals)
- It fails safely (Lyapunov stability guarantees, bounded trust regions)
- It learns gradually (two-timescale updates: fast routing, slow metric adaptation)
- It's motivated by its own measurements (self-supervised from task outcomes)
- It improves steadily over time (online learning with convergence guarantees)
This is not interdisciplinary synthesis. This is recognizing that different fields have independently discovered the same underlying principles. The mathematics makes it rigorous; the pedagogy makes it interpretable.
We built Compitum because we believe AI systems should learn the way humans do: honestly, gradually, and with humility.
If you're an educator, you already understand these principles better than most engineers do. Your expertise in designing learning environments translates directly to designing learning algorithms. We need your wisdom—not as "outreach" or "broader impacts," but as core intellectual contribution.
If you're a researcher, consider this: What if we've been solving the wrong problem? We obsess over architecture search and training techniques, but perhaps the bottleneck isn't model capacity—it's system capacity to learn from deployment. Montessori solved online learning in 1907. We're just catching up with better notation.
If you're curious about the technical details, our technical documentation provides proofs, ablations, and convergence analyses. But the core insight is here: good systems, like good materials, contain their own feedback.
The Pink Tower doesn't need a teacher standing next to it. It teaches itself.
That's what we're building for AI—not through clever architecture, but through careful system design that closes the learning loop.
- For Educators: Read about Control of Error in Practice to see how our testing pipeline embodies Montessori principles
- For Engineers: Start with Getting Started to see the code
- For Researchers: Explore Mathematics for formal treatment
- For the Curious: Browse Examples to see decisions explained
The entry point doesn't matter. What matters is that you see: this isn't just math. It's pedagogy.
And pedagogy is where teachers have been leading the way for centuries.
You may notice this document moves fluidly between pedagogical metaphor and technical precision. This is intentional.
The Montessori method is rigorous—it makes falsifiable predictions about learning outcomes and has survived a century of empirical scrutiny. Accessible explanation doesn't require sacrificing technical content; it requires choosing the right abstractions and making implicit assumptions explicit.
For researchers: The formal treatment lives in our technical documentation—convergence proofs for metric updates, sample complexity bounds, ablation studies. This introduction establishes why these problems matter before diving into how we solve them.
Different audiences need different entry points. Pedagogical language and mathematical language can both make precise, testable claims. We're fluent in both.
Welcome to Compitum. Let's learn together.