Can a trained model be fixed without retraining it?
This was Perception's first research program, and the papers and notes below remain its record. What we learned — that supervised patches leak into capabilities they were never meant to touch, fail when combined, and look better by training loss than they are — is why our central work is now RL environments.
That was the research question at the centre of Perception's first program. Training a large model costs real money and real energy. When it doesn't behave the way we need, the default answer is to retrain — or to discard the model entirely. We're working on a third option: surgical edits to the weights and representations of models that already exist.
The bet is that the cost a team has already paid for pre-training or fine-tuning can be recovered through precise interventions, rather than written off. If true, it changes what "alignment" means in practice — alignment as repair, not alignment as restart.
The program — certified capability repair
The program treated repair as a lifecycle, not a one-off edit. An observed failure is classified; a capability is selected against strict eligibility criteria (it must be measurable, repeatable, isolable, and benchmarkable); a patch is generated; and the patch is judged by a certificate — a per-dimension, pass/fail measurement of whether the target capability actually improved, whether the declared neighborhood stayed put, whether general ability regressed, and what the patch cost. Patches that will be installed together additionally need a composition proof: evidence they survive co-installation.
The certificate, not the patch, is the product. A patch is a claim; the certificate is the evidence. The eventual system contract is simple to state — input: failure examples; output: a certified patch.
The first study is concluded and written up as a working paper. Along the way the certificate refused a patch that looked perfect by training loss; we calibrated its thresholds from a measured noise floor so the verdicts mean something; we found that low-rank patches reach the edge of certifiability but land on it; and we settled how to install two patches at once — the answer is to route between them, not merge their weights, because naive merging drops both capabilities below the unpatched model. The findings hold up under pressure: the measuring-stick result is a near-deterministic law across a 5× range of model sizes, and the whole framework transfers to a second, unrelated domain (tool-calling) on an external benchmark.
Read the paper — You Cannot Trust a Patch Without a Certificate · PDF
Shorter write-ups of the findings:
- You can't trust a patch without a certificate — the concluded study: calibration, the patch-mechanism wall, and route-don't-merge.
- Certified capability repair: what we've learned so far — the first results: honest measurement, a leaky patch caught, composition collapse.
Publications
Working papers, released as they conclude.
- 2026-06-19
When does an LLM help a GNN on relational data?
A paired-baseline study of graph-conditioned LLMs: they tie but don’t beat a well-tuned GNN, while a structured GNN encoding beats flat-text RAG by ~50× on token cost. The GNN is the predictor; the LLM is the interface.
Read · PDF - 2026-06-16
You cannot trust a patch without a certificate
The unit of trust in model repair is the certificate, not the patch: a patch that looks perfect by training loss can leak, merging two good patches destroys both, and the safe install is to route, not merge — verified across two model scales and a second domain.
Read · PDF
Techniques we worked with
Causal tracing
Before you can edit a behaviour, you have to find it. Causal tracing identifies which layers and components in a model are actually responsible for a given output. The goal is precision — knowing where to intervene without disturbing what is already working.
Rank-one model editing (ROME)
ROME is a technique for updating specific factual or behavioural associations in a model with a minimal, targeted weight change. We treat it as a foundational primitive: small, verifiable, reversible edits — the opposite of full retraining.
Task vectors and weight arithmetic
Fine-tuning produces a direction in weight space. Task vectors let us add, subtract, and compose those directions across models. This opens up a question we care about: can you remove a learned behaviour as cleanly as you added it?
Representation engineering (RepE)
Some behaviours don't live in weights — they live in the activations as the model runs. Representation engineering operates on those activations directly, steering behaviour at inference time. It complements weight editing and gives us a second control surface.
What we are not
We are not a foundation-model lab. We do not train models from scratch. Our research starts from the assumption that the model already exists, the training run already happened, and the question is what to do next.
The applied bet
Editing a model precisely is only useful if you know what better looks like. Most "alignment" work answers this with proxies — benchmarks, preference data, rule sets. We think the harder and more honest answer is longitudinal evidence of how an individual actually develops over time.
That is what Sage is building, starting with childhood. The two threads — precision editing and longitudinal evidence — meet in the same question: how do you make AI useful to a specific human, not a generic one, without retraining from zero for each person?