how do you learn the frontier fast?

start from the problem, not the paper

the first z0intelligence question was not “what is the best router?” or “how does jev work?” it was more primitive: how much expensive general intelligence does an agent actually need on each step?

from the outside an agent loop looks like one continuous act of intelligence. zoom in and the loop fractures into very different computational jobs: understand an open-ended request, retrieve context, decide whether a tool is relevant, choose among a few legal actions, notice a retry condition, verify an outcome, decide whether to escalate, and only sometimes do genuinely novel reasoning.

that distinction matters because a frontier language model is an incredibly general machine. if the runtime asks it to solve a five-way choice, we are buying the ability to generate the entire language distribution and then using a microscopic slice of that capability.

that question became more useful than “which model is smartest?” because it forces us to identify the function before choosing the implementation.

a decision is not necessarily a generation problem

an autoregressive language model learns a distribution over sequences. at inference time it repeatedly predicts the next token, appends it, and predicts again. that interface is beautiful when the desired output is language. it is less obviously necessary when the desired output is one element from a set that the program already knows.

for a bounded decision, the mathematical object we usually care about is closer to:

state s
legal actions A(s) = {a1, a2, ... ak}
learn or estimate p(a | s, A(s))
choose, abstain, or escalate

once you write the problem that way, decades of classification, ranking, selective prediction, calibration and decision theory become relevant. “use a chatbot” stops being the default formulation.

this was the first big meta-research lesson: rename the problem in the language of older fields. the newest product may be six months old while the core mathematical problem is fifty years old.

from bert to decision models

modern language models did not invent text classification. the interesting transition was representation learning. bag-of-words models could already map text to labels, but their representation was mostly lexical. recurrent and convolutional models learned more structure. transformers then made it practical to pretrain a reusable representation on enormous text corpora and adapt it to many downstream tasks.

bert is the obvious landmark. its encoder sees left and right context together, and the paper showed that a pretrained representation could be adapted to many tasks with a small output layer. the important conceptual point for us was not “bert is good.” it was that language understanding and language generation do not have to be the same computation.

that line did not disappear when decoder-only llms took over the cultural conversation.modernbert revisited the encoder-only design with modern training and systems optimizations and found a strong performance/size/memory frontier for classification and retrieval. meanwhile, a large controlled study ofarchitecture and pretraining objective found that causal autoregressive models are especially strong after pure unsupervised pretraining, while non-causal visibility plus multitask adaptation can be extremely competitive after task training.

the lesson is not “encoders beat decoders.” the lesson is that the right inductive bias depends on the job. generation rewards a model that can continue arbitrary sequences. classification and ranking can exploit the fact that the output space is already constrained.

what jev actually changed

this is why jev was interesting to us. not because classification was new, but becausetypesafe made a different interface culturally legible again: unstructured state in, typed probabilistic decisions out. choice, binary judgment and score-shaped questions are first-class outputs rather than text that another parser has to interpret.

there is a temptation to reverse-engineer the secret model from that behavior. we should not. typesafe publicly says jev uses a new architecture, a parallel sampler and a training method called reinforcement learning for calibrated decisions. it does not publish the architecture, parameter count, full corpus or RLCD algorithm. sebastian raschka'sexcellent classifier history argues that a modern encoder-like design is a plausible explanation. plausible is not the same as known.

that distinction changed OpenJev and later z0intelligence. instead of pretending we could reproduce a hidden checkpoint, we reproduced the useful systems pattern: runtime-defined options, direct logit readout, shared-state reuse, trainable bounded scorers, probabilities, and explicit abstention.

on one committed local benchmark, our direct typed-logit path returned 21 probability pairs in about 1.023 seconds median versus 5.332 seconds for the compact autoregressive baseline. that measurement did not prove we had recreated jev. it proved that changing the output contract alone could remove a lot of unnecessary generation.

then the compiler changed the question

our first instinct was still model-centric: find a tiny model that makes the right choice. the compiler-first experiments changed that.

if an action violates authority, dependencies, privacy constraints or the task grammar, why should a learned policy receive that action as an option? a deterministic layer can remove it before inference. this is the same separation that later became explicit in AODL: intent, constraints and authority are not merely hints in a prompt; they can be represented as typed structure outside the model.

raw state
   ↓
compile constraints + legal action set
   ↓
only then ask a learned policy to rank the legal residue

in our early bounded-choice runs, removing illegal actions eliminated dangerous selections that appeared in the unfiltered control. more importantly, the compiler made the learned job easier. this is a recurring systems pattern: the best model optimization may be to shrink the model's problem.

this was the origin of the current z0intelligence boundary. the model is not the authority. code owns legality, budgets, side effects and verification. learned systems operate inside the remaining uncertainty.

probability has to mean something

once a model's confidence controls execution, confidence stops being decorative metadata. it becomes part of the program.

suppose two classifiers both get 90% accuracy. one says 0.9 on the cases it gets right and 0.1 on the cases it gets wrong. the other says 0.999 on everything. they have similar top-1 accuracy and radically different value as routing primitives.

the statistical literature has a language for this. thebrier score dates to probability forecasting in 1950.gneiting and raftery explain the broader theory of strictly proper scoring rules: if the score is proper, a forecaster maximizes expected reward by reporting its real belief rather than gaming the score.

deep neural networks complicated the picture. guo et al. showed that modern neural networks can be accurate and badly calibrated at the same time, and that simple temperature scaling often repairs a surprising amount of the gap.

this is also why the distinction between RLCD and public calibration-aware RL work matters.RLCR adds a proper-scoring component to the reinforcement-learning reward so a reasoning model is rewarded for calibrated confidence as well as correctness. it is a useful public mechanism for understanding why a calibration objective can work. there is no evidence that typesafe's unpublished RLCD algorithm is the same algorithm.

abstention is old and extremely useful

if confidence is meaningful, the next question is obvious: why force the cheap model to answer every case?

this is not a new trick. chow's 1970 reject-option work studies the optimal tradeoff between recognition error and rejection. modern selective classification asks the same systems question: how much of the input distribution can a model cover while keeping risk below a target?

selectivenet goes further by learning prediction and rejection together. the important object is the risk-coverage curve, not one global accuracy number.

this directly changed our metric. early z0intelligence experiments kept asking “which tiny policy has the highest accuracy?” the better production question became:at 95% precision, what fraction of real decisions can this cheap policy safely absorb?

that reframing is enormous. a 400-million-parameter policy does not need to replace a frontier model. if it can safely absorb 20% of a high-volume decision family, it may already be useful. the hard tail can remain hard.

conditional compute is the bigger idea

at this point the research trail expands beyond classifiers. what we were really building was a form of conditional computation: spend more compute only when the current state earns it.

mixture-of-experts models are one famous version. insparsely gated mixture of experts, a learned gate activates only a subset of a huge network. switch transformers simplify that routing and show how sparse activation can increase capacity without proportional per-example compute.

early-exit networks attack the problem along depth instead of width.deebert lets easy examples leave before traversing the full transformer; fastbert similarly makes inference depth adaptive.

llm cascades lift the same idea to whole models.frugalgpt formalized a family of strategies including cascades that conditionally move from cheap models to expensive ones.routellm learns a router between stronger and weaker llms from preference data.

these are different implementations of one principle:

easy state → stop early
ambiguous state → spend more
hard state → spend the expensive capability

our first z0intelligence ladder was basically this principle drawn as a stack of products: rule → tiny specialist → nanojev/jev → small slm → orchestrator → frontier model.

then the router literature humbled us

a beautiful cascade diagram is not evidence that routing works.

the recent routing literature is increasingly useful because it is becoming harder on itself.routerarena exists because router papers were difficult to compare under different pools, datasets and metrics.llmrouterbench re-evaluated routing over more than 400,000 instances, 21 datasets and 33 models. its uncomfortable result is that many seemingly different routers become nearly indistinguishable under one framework, and several fail to reliably beat simple baselines.

this was exactly the kind of result our own traces were starting to produce. on a sealed real-trace tool-family routing cohort, a tiny deterministic keyword policy beat the learned Laya and Julia fast paths by a large margin. after fixing Julia's adapter until its publisher benchmark reproduced, the real-task result still did not improve. faithful integration was not the problem. task fit was.

a useful independent Jev routing experiment tells the same story from another angle.TokenTrim combined retrieval evidence with a Jev difficulty score and reached a strong cost/accuracy frontier on LLMRouterBench. then the no-Jev ablation reached essentially the same frontier. retrieval was carrying the gain.

this is what good research looks like: the ablation makes the headline less exciting and the understanding more useful.

model choice became a systems problem

the machine-learning framing still missed something important: a model has to be loaded, served, scheduled and given context.

phase 1b measured a local cold-load p50 around 13.9 seconds and model swaps around 12.9 seconds on the relevant path. some warm decisions were hundreds of milliseconds. once the load cost is two orders of magnitude larger than the forward pass, a router that ignores residency can make a mathematically “better” choice and a systemically terrible one.

this produced one of the cleaner architecture boundaries in the project:

z0intelligence: should this cognition happen, and what capability is justified?
kerdoios: where should the residual allowed computation run?
harness: execute it
tokenomics: record what actually happened and cost
z0evals: freeze the evidence before we believe the promotion

the same lesson appears inside sparse models: switch transformers are not just about a gate; communication, load balancing and hardware behavior matter. conditional compute is always a systems problem eventually.

more intelligence can be negative information

another assumption that sounded obvious was that two useful models should compose into a more useful system.

our composition experiments did the opposite. a NanoJev artifact was actually produced and consumed on almost every state, yet adding it in front of Qwen4B hurt the downstream result. Hammer pre-composition was worse again. the extra model output was real. the gain was not.

this changed how we think about delegation too. a fast Cerebras worker later completed its assigned work cleanly, but the parent still consumed the original task plus a large worker response. the worker got faster; the parent did not do less.

the relevant optimization target is therefore not “did a worker run?” it is how much expensive cognition disappeared while verified outcome quality stayed fixed?

that pushes the architecture toward typed, compressed intermediate representations. a worker that can return one validated decision, artifact handle or minimal evidence packet can be more valuable than a smarter worker that returns another essay for the parent to reread.

specialize the repeated cognition

the original personal-intelligence idea was much simpler: train a small language or vision-language model on a user's history so it understands how they work.

the research above made that idea more compositional. mutable facts should be retrieved with provenance. stable repeated behavior can be learned. and each repeated behavior should be allowed to choose its own cheapest representation.

history → episodes of state / action / outcome

then compete:
rule
ridge / linear
mlp
mushroom-body policy
temporal recurrent policy
small semantic model
frontier model

that is why z0intelligence now looks more like a population of specialists than one student model. the model family is not sacred. deterministic rules remain mandatory controls. a learned model only earns traffic if it expands the measured quality/coverage/latency frontier.

this also explains why observed trajectories are more valuable than giant manual labeling projects. agent histories already contain weak and strong supervision: actions, retries, tests, tool results, corrections, merges, rejections and downstream outcomes. the research problem is to compile those traces into causally honest episodes without leaking future information into the input.

why we looked at flies

the fly work can look like a strange detour if you start from llm routing. it makes more sense if you start from the question “what is the smallest trainable mechanism that can reliably associate a high-dimensional state with a bounded action?”

the drosophila mushroom body is a compact associative-learning system. the 2017 larval mushroom-body connectome found that most Kenyon cells integrate combinations of projection-neuron inputs, producing a sparse expanded representation that feeds learned output pathways. this resembles a useful machine-learning recipe: expand, sparsify, then train a tiny readout.

connectomics later scaled dramatically. the 2023larval whole-brain connectomemapped 3,016 neurons and 548,000 synapses. the 2024adult FlyWire connectomereached roughly 139,000 neurons and tens of millions of synapses.

our first reaction was predictable: maybe a whole evolved circuit gives us a better tiny controller. the better research stance is stricter. biology is a hypothesis generator, not an authority.

full MaleCNS-scale simulation has to compete with a GRU, random reservoir, rewired topology, ridge model and the distilled motif itself. if a tiny mushroom-body-style readout preserves the useful effect, deploy the tiny readout. the interesting biological circuit can stay in the lab.

the end state is downward compilation

this is the idea that now unifies the whole project.

novel task
  ↓
frontier reasoning
  ↓ repeated evidence
bounded learned specialist
  ↓ stable region
deterministic routine
  ↓
no model call

we call this “compiling cognition downward.” it resembles distillation, cascades and early exit, but the representation is allowed to change completely. a frontier decision can become an slm policy; the slm policy can become a sparse tiny classifier; the stable region of that classifier can become a declarative rule.

the routine compiler in z0intelligence is deliberately conservative: discover on open data, tune on development data, credit only on sealed data, preserve fallback, and demote when future evidence drifts. the point is not to generate clever rules with an llm. the point is to prove that a region no longer needs a learned model.

how we actually did the research

the most important thing llms changed for me was not that they could summarize papers. paper summaries are cheap. the useful change was that i could keep a much larger hypothesis graph alive at once.

the loop that emerged eventually got a name in our repos — ABAB — but the structure is older than the name:

A: diagnose the phenomenon and propose rival explanations
B: run a frozen experiment that could falsify them
A: update the mental model from the result
B: run the smallest next experiment that distinguishes what remains

this is closely related to Bayesian experimental design and active learning. inMacKay's 1992 information-based active data selection, candidate measurements are valued by how much information they are expected to provide. our practical version is:prefer the cheapest experiment whose possible outcomes would make us choose different architectures.

that rule saved us from endless benchmark sweeps. when two explanations remain, adding ten more models is often lower-value than one test designed so hypothesis A and hypothesis B make opposite predictions.

the other half is the frozen judge. the system proposing the experiment cannot be allowed to rewrite the criterion that decides whether it won. that is why z0evals, sealed cohorts, independent outcomes and exact execution receipts became architectural components rather than paperwork.

what llms accelerate — and what they do not

recent work on llms for science makes the opportunity and the limitation pretty clear. systems such as the ai co-scientist andagent laboratory show that llms can help with literature search, hypothesis generation, code, experimentation and writing. at the same time, a recentscientific-discovery evaluation finds a substantial gap between doing well on science questions and succeeding at iterative, scenario-grounded discovery.

that matches our experience. llms are extraordinary research compressors when they are used to:

• translate a vague phenomenon into the vocabulary of several fields;
• walk backward through citations until the idea stops looking new;
• explain prerequisite mathematics at exactly the depth needed for the next paper;
• compare methods under one set of assumptions;
• generate competing explanations instead of one confident story;
• turn those explanations into runnable discriminating experiments;
• write instrumentation, replay harnesses and analysis code quickly;
• preserve a research ledger so yesterday's failed hypothesis is not rediscovered next week.

but the llm should not get to decide that its own explanation is correct. the expensive human skill is still research judgment: deciding what question matters, what evidence would change the architecture, whether a benchmark represents the real distribution, and whether two measurements are actually comparable.

our current synthesis of the frontier

“state of the art” is usually presented as a model leaderboard. the z0intelligence research trail makes me think the more interesting frontier is architectural.

there are already routing systems moving toward online feedback. for example,bandit-feedback routing treats model selection as a contextual-bandit problem where only the chosen model's outcome may be observed, which is much closer to deployment than assuming a complete reward matrix.orcarouter similarly combines offline initialization with optional online contextual-bandit updates.

the z0intelligence version adds another axis: the action is not always “choose an llm.” the action may be “use a rule,” “retrieve context,” “run a tiny specialist,” “ask a calibrated decision model,” “load a local slm,” or “spend the frontier model.”

the experiments that would change my mind

a research synthesis should end with falsifiers, not vibes. these are the experiments that matter most to the current theory:

1. option-conditioned tiny policy vs direct semantic scorer. can one small dynamic-option specialist generalize across changing tool/skill sets while preserving calibrated risk/coverage?
2. residency-aware routing. does adding current memory residency, swap cost and queue state materially beat a quality-only router on end-to-end verified utility?
3. typed delegation. if a worker returns a compact typed artifact instead of prose, does parent token use finally fall without lowering task success?
4. routine compilation. what fraction of a credited specialist's stable region can be replaced by deterministic rules on future traffic?
5. mushroom-body vs boring controls. on real outcome-backed decision families, does sparse local plasticity beat ridge/MLP at the same footprint and safe-coverage target?
6. active-label allocation. does asking Jev/frontier teachers only on disagreement and high-information states outperform labeling everything at equal cost?
7. cross-harness transfer. does a policy learned from one harness preserve its lift on another, or are we mostly learning harness-specific surface cues?

if these fail, the architecture should get simpler again.

a reusable way to learn a field fast

if i had to turn this experience into a playbook for learning a technical frontier with llms, it would look like this:

1. start with a painful real phenomenon. “why is this slow?” is better than “teach me model routing.”
2. decompose the phenomenon into smaller mathematical jobs. generation, classification, ranking, retrieval, control, scheduling, verification and optimization have different literatures.
3. use the llm to discover vocabulary and walk the citation graph backward.keep asking “what older field already studied this?”
4. build rival explanations. do not let the research session collapse into one persuasive narrative.
5. run the smallest discriminating experiment. maximize expected information gain, not benchmark volume.
6. freeze evidence before interpretation. preserve traces, revisions, negatives and failed hypotheses.
7. compress the result into a new mental model, then repeat. the output of research is not the paper summary. it is a model that predicts what the next experiment should do.

this is the part that feels genuinely new in the llm era. the barrier to entering a field used to include an enormous amount of mechanical search, prerequisite lookup, code translation and notation decoding. llms can compress much of that. they cannot remove the need to decide what is true.

paper map

this is the compact research trail behind the story. “used by us” means it influenced a hypothesis or interpretation; it does not imply that the paper proves our architecture.

our evidence checkpoints

• phase 1b: how much of the llm do we actually need? — compiler-first legality, Hammer/Qwen/Nemotron/FunctionGemma/NanoJev comparisons, residency, composition, orchestration and the first architecture collapse.
• what actually deserves a model? — the later evidence: real Jev reproduction correction, NanoJev objective failure, Laya/Julia, real-trace rule routing, physical provider execution, free-tier and Cerebras delegation.
• z0intelligence research context — the durable research ledger: retrieve truth / learn behavior, safe coverage, specialists, mushroom bodies, ABAB and downward compilation.

claim discipline

the research loop in one screen

real phenomenon
→ name the smaller mathematical problem
→ map the literature backward
→ keep rival explanations
→ choose the cheapest discriminating experiment
→ freeze execution + outcome evidence
→ update the theory
→ compile the winning behavior downward
→ repeat