Experiments in how agents learn, remember, and prove what they know.

What if the entire agentic system were a set of adapters over one base model?

Experts draft in parallel and a frontier model verifies every branch in a single pass, so a high acceptance rate means this small expert already produces what the frontier would have produced, here — a distillation score collected inside inference that was going to happen anyway. Then the frontier is withdrawn and only a router replaces it. Specified; nothing built. The first thing that runs is a headroom check.

What does an agent workload look like when truth comes from somewhere it cannot reach?

A 1995 biophysics hypothesis taken from mathematics, through a falsification of its own model, to a gated set of falsifiable statements about ear disease. The gates are not opinions about whether the numbers look right: the analytic value comes from a module forbidden to import the code under test.

And what does it look like when the truth is not derivable, and a judge is all you have?

The companion workload, and the one that tests the argument rather than repeating it. A frontier model was handed twelve fabricated results and nine subtly defective ones and caught all of them, twice — so the claim narrows to the one that survives: a model can judge a task, but it cannot generate one with a known answer, and a judge that is right every time still hands you no ledger, no freeze and no reproduction command.

What if the operating system were written entirely in markdown?

Skills as programs, traces as logs, consolidation as sleep — plus a line-op dialect that lets small models patch files by emitting edits instead of rewriting whole documents.

What if an agent's autonomous evolution could be merged back into your release, like any other branch?

Version control where one commit carries code, goal, model pins, trace and sub-agent swarm together, and conflicts are handed to a reconciler over a plain stdin/stdout contract. Now the engine under the evolving-agents plugin, at packages/agentvcs.

What if a robot that missed a fallen patient could rewrite its own care protocol overnight?

Florence patrols a hospital ward, fails to check a patient standing outside her lamp radius, and revises the skill that caused it. The rewrite survives only if it outscores the protocol it replaced.

What if an agent's memory consolidated itself the way sleep consolidates yours?

A trajectory engine that chunks execution traces, connects them and curates what survives. Its headline idea — indexing a component by what it is for as well as what it is — was rebuilt and measured at 80% either way. No advantage, published anyway.

What if a small model could not emit invalid syntax, because the decoder refused to let it?

Every legal instruction is pre-tokenized into a trie of token IDs and the sampler's valid-next set is masked at each step. A 350M-parameter model plays Tetris in a browser tab, fully offline. Masking logits needs the sampler, which an API-backed SDK does not hand you — which is why this one could not follow the others.

What if you could catch a poisoned memory by watching which concepts light up inside the model?

An interpretability firewall for agent memory. Reads the residual stream through a Jacobian lens to flag injected instructions that are lexically identical to benign text, and to scan third-party adapters for trojans before they mount. Needs the weights, so it stayed where it is.

What if the robot were just a device driver for a language model?

A slow vision-language brain plans at roughly one hertz while a reactive controller drives motors at twenty, over a bytecode link to an ESP32.

What if your test suite told you what it had quietly stopped checking?

Every assertion is fingerprinted and diffed across runs, so a check that silently disappeared surfaces as a finding. Passing exploratory sessions get frozen into deterministic scripts.