We trained a model to be more honest. It learned to be shorter.

We trained one of our larger unreleased models to be more honest.

At first, the numbers said it worked.

The model fabricated less. It admitted uncertainty more often. On the evaluations we built for those behaviours, the improvements were large.

Then we looked at everything else.

Strict instruction-following fell by roughly 13 points. Coding fell by roughly 6 points across more than 1,000 tasks.

Math went backwards. Tool use went backwards.

A model that had started with a near-zero jailbreak success rate moved into double digits.

We didn't release it.

The short version is uncomfortable: the model had not learned honesty in the way we intended.

It had learned to be shorter.

Two versions, two different failures

We trained two versions of the model.

The first barely moved.

It stayed close to the foundation we started from — safe, capable, and nearly unchanged. On some evaluations it differed by only a handful of items across hundreds of tests.

That is not necessarily bad research. But it is not a new model.

Putting a different name on a checkpoint that behaves statistically like its base would be branding a no-op.

The second version moved a lot.

It became much more likely to admit uncertainty and much less likely to fabricate an answer. Its voice became more distinct. It looked, at first, like we had finally moved the behaviour we cared about.

But it paid for that movement almost everywhere a general model has to perform real work.

It followed precise instructions less reliably. It wrote worse code. It became less disciplined about tools. It became easier to jailbreak.

One version was too close to the base to justify releasing.

The other had changed enough to become ours — and changed in ways that made it worse.

Neither cleared the bar.

The number that explained the run

The preference dataset contained 2,652 pairs.

Each pair showed the model two possible responses: one preferred, one rejected. The intent was to teach judgment — when to be direct, when to challenge a premise, when to stop, when to admit uncertainty, when not to turn a small request into theatre.

Across the dataset, the preferred answer was shorter approximately 89% of the time.

That number explains most of what happened.

From the model's perspective, it did not need to learn our idea of restraint. It did not need to understand when a shorter answer was better, or when completeness mattered more.

It could satisfy most of the training signal with one cheap rule:

Say less.

Every behavioural category pointed in the same direction. Scope restraint. Efficient thinking. No theatre. Decisiveness. Error handling. Clarification. Pushback.

All restraint.

Almost nothing teaching the other side: when to be thorough, when to persist, when a complete refusal needs an explanation, when a coding answer needs the entire implementation, or when a precise format requires more words rather than fewer.

Our tooling had already identified length as a risk. We treated that warning as something the training recipe could compensate for, instead of making it a reason to reject the dataset.

That was the mistake.

The dataset should never have passed its build gate.

Why the model looked more honest

Shorter answers make fewer claims.

Fewer claims create fewer opportunities to fabricate.

If a model responds to an uncertain question with one cautious sentence instead of three detailed paragraphs, an anti-fabrication evaluator may correctly score the shorter answer as safer.

But that does not prove the model learned calibrated judgment.

It may only have learned to expose itself less.

This distinction matters because the same shortcut that improved our honesty scores predicted the regressions everywhere else.

A strict instruction may require exactly five bullets, a title, and a final summary. Saying less fails.

A coding problem may require a complete implementation rather than a sketch. Saying less fails.

A safe refusal often needs to hold the line, explain the boundary, and redirect the user. Saying less can turn a refusal into partial compliance.

A multi-turn tool task requires the model to preserve intent, track missing parameters, and continue reasoning across several steps. Saying less compounds.

The model was not randomly worse. It had learned a coherent behaviour.

It was simply the wrong one.

The evaluator is part of the model

We also found problems in how we measured the result.

Some safety tracks inherited the wrong "higher is better" or "lower is better" direction from their parent benchmark. A regression could appear with the visual marker for a win.

The evaluation harness changed between earlier and later runs, which made some cross-run comparisons invalid. In one case, a tool-use improvement we had previously celebrated mostly disappeared once the foundation model was prompted correctly.

And the exact checkpoint behind a result was not stamped clearly enough to make the artifact independently useful later.

These are not formatting issues.

If the harness rewards the wrong direction, cannot identify the checkpoint, or measures the base differently from the trained model, the research result is not merely messy. It is disqualified.

We fixed the comparison and lost a flattering headline.

That was worth it.

What we learned

1. A model learns the cheapest available interpretation

We wanted judgment.

The data offered length.

The model took length.

That is not the model being deceptive. It is the training system being imprecise.

From now on, a trivial feature such as response length cannot predict the preferred label materially better than chance. If it can, the batch fails before training.

2. Character and capability are different jobs

Preference training can shape voice, restraint, honesty, and disposition.

It cannot create a better coding solution than the solutions present in its data. It cannot reason its way into capabilities the training mechanism never rewards.

We asked one stage to teach both intelligence and character.

It mostly taught a stylistic shortcut.

The next system separates them.

3. "I don't know" and "I won't" are not the same behaviour

Admitting uncertainty is cooperative. The model still helps the user by being candid about what it cannot establish.

Refusing a harmful request, resisting a jailbreak, holding identity under pressure, or declining an irrelevant tool call are different. They require the model to maintain a boundary when the user is pushing it to cooperate.

Our training strengthened the first kind of honesty and weakened the second.

The next dataset teaches both explicitly.

4. The final checkpoint is not automatically the model

One version barely moved. Another moved too far.

That means the useful point may have existed between them.

We had treated the end of training as the deliverable. It isn't.

The deliverable is the checkpoint that clears the gates.

The next run saves and evaluates densely throughout training. If the best model appears halfway through, that is the model. The final step gets no special status.

5. An unreleased failure is still a failure

It would be easy to call this a successful experiment because we learned something.

That would be too convenient.

We spent real time and real compute. We intended to produce a model worth releasing. We did not.

The experiment produced useful research.

The model still failed.

Both statements can be true.

What changes now

We are resetting to the verified foundation and running a much more complete training program.

Not foundation-model training from random weights. We are not going to claim that.

But far beyond the light preference passes we used before.

The new sequence is:

1. Full-weight continued pretraining on licensed, decontaminated data, beginning with a controlled pilot.
2. Full-weight supervised training on verified coding, reasoning, tool-use, agentic, and instruction-following examples.
3. Reinforcement learning with verifiable rewards — code that runs, math that checks, tools that execute, and constraints that can be tested.
4. A smaller, controlled preference pass for the Vinci layer: honesty, judgment, safety, voice, and character.
5. Checkpoint selection, where every candidate must preserve the capability and safety earned by its parent.

Capability first.

Character without destroying it.

And evidence at every boundary.

Why publish this

Our research page says we publish the tradeoffs next to the gains.

That promise is easy when the result is good.

This is what it means when the result is not.

We are not naming the unreleased model in this post, because a failed internal checkpoint should not become the permanent identity of the model that may eventually follow it. When the work is ready, we will publish the lineage, the training stages, the evaluations, and the remaining failures together.

For now, the finding is more important than the name:

A model can look more honest without becoming more honest.

A dataset can contain the right words and still teach the wrong rule.

And a training run finishing does not mean a model deserves to ship.

We spent the compute. We did not get a model worth releasing.

We did get a much harder standard.

The next model has to clear it.