Ouro-2.6B-RLTT

A looped language model for latent reasoning and recurrent-state research. Ouro-2.6B-RLTT applies a shared 48-block transformer stack over four recurrent passes and has been post-trained with Reward Latent Thought Trajectories (RLTT). The recurrent states support research into reasoning quality, representation development and control of internal computation.

This Hugging Face export contains BF16 safetensors, the tokenizer and custom model code, converted from a four-rank FSDP/DTensor checkpoint. Format conversion adds no further training.

Background: Ouro and RLTT

Ouro repeatedly applies a shared transformer stack before predicting each next token. Each loop exposes an intermediate hidden state, making recurrent depth an axis for both computation and analysis. The starting model is ByteDance/Ouro-2.6B-Thinking.

RLTT means Reward Latent Thought Trajectories. Its training-method paper is Prioritize the Process, Not Just the Outcome: Rewarding Latent Thought Trajectories Improves Reasoning in Looped Language Models, ICML 2026. arXiv version · Training and evaluation code.

During RLTT post-training, final-answer correctness supplies a reward for each sampled response. Group-normalized advantages weight the response tokens' log-probabilities across multiple loop depths, giving intermediate predictions direct credit. A reference-policy KL term constrains the terminal distribution. Ordinary terminal-loop objectives also backpropagate through earlier loops; RLTT adds direct loop-wise objective terms. It does not require a separate learned process grader, but still uses ground-truth outcome rewards.

The paper evaluates fixed four-loop models, including exit-probability-weighted credit. Those weights do not mean its experiments adaptively halt computation. Generation uses terminal-loop predictions, and may still produce visible step-by-step reasoning. Published benchmark numbers and training settings are results for the authors' reported runs; this export has not been bound to a specific table row, seed or training step.

What is in this checkpoint

Configuration and tensor inventory of this export:

Property	Stored setting
Model class	OuroForCausalLM, custom Transformers code
Stored parameters	2,667,974,657 across 533 tensors
Physical transformer stack	48 blocks, shared across recurrent passes
Default recurrence	Four passes of the stack per token
Hidden / feed-forward width	2,048 / 5,632
Attention	16 query heads and 16 KV heads, head dimension 128
Vocabulary	49,152 tokens
Weights	BF16, three safetensors shards; approximately 5.34 GB on disk
Position configuration	RoPE; max_position_embeddings=65536
Conversion source	Four-rank FSDP/DTensor checkpoint
Recorded Transformers version	4.54.1

Reusing weights saves stored parameters relative to an independently parameterized stack of equivalent executed depth. Four passes still incur four passes of transformer computation; the parameter count is not an inference-cost equivalence. The configured positional limit alone does not establish reliable 65,536-token performance.

The custom runtime includes loop-wise outputs and configurable research controls. For comparable experiments, specify loop count, readout policy, exit settings, precision, cache policy and decoding budget.

Research using this work

RLTT: trajectory-level reinforcement learning

Prioritize the Process, Not Just the Outcome: Rewarding Latent Thought Trajectories Improves Reasoning in Looped Language Models — arXiv · code.

The original RLTT paper introduces direct loop-wise outcome credit for Ouro post-training and evaluates mathematical and non-mathematical reasoning, loop-depth and decoding-budget robustness, and training dynamics. It is the method reference for this checkpoint. Its benchmark tables describe the paper's reported runs; this export has no verified mapping to a particular training step, seed or ablation variant.

Operational Proto-Introspection

Operational Proto-Introspection in Looped Language Models: Process-Quality Taps, Executable Branching, and the Readout-Control Boundary.

Ouro-RLTT is the primary frozen backbone in this work. The research studies whether hidden states contain information about answer quality, how that information develops across physical depth and recurrent loops, and whether external readouts can support selection or interventions. Its distinction between readable information and usable generative control matters: a probe predicting success is not evidence that the model consciously inspects itself or can use that signal to improve its own generation.

Research code: Branching-Looped-Transformer.

Related preference-readout work

Relational Preference Encoding in Looped Transformer Internal States.

This is related precursor work on preference readouts in Ouro's internal states. The original evaluator used Ouro-2.6B-Thinking. The full-test-set audit reported in the public v2 erratum uses Ouro-RLTT. The erratum corrects the original headline results; this history is part of the research record. Read it with the Hidden-State-Evaluator code and correction record.

Further uses of the RLTT objective

The following studies implement or evaluate RLTT on their own backbones. They are method-level references, with no verified connection to this specific 2.6B weight export.

• Closing the Loop: Practical Training Recipes for Looped Language Models evaluates RLTT post-training on its own 1.4B LoopLM, reporting six configurations in Appendix C. Its main benchmark results are reported without reinforcement learning; the RLTT trials are a separate post-training study.
• LatentHarness: Learning Latent Actions for Memory and Reasoning via Counterfactual Policy Distillation uses RLTT-style dense loop-wise supervision and evaluates RLTT baselines, including a four-loop All-Think diagnostic, alongside learned THINK/RECALL/EXIT control. The experiments use checkpoints trained within that study.

Loading the model

The recorded runtime uses Transformers 4.54.1; the example also needs PyTorch and Accelerate for device_map="auto". The repository supplies custom Python model definitions, so loading requires trust_remote_code=True. The example below uses four loops and disables caching, matching the conservative research path used locally. It is a source-reviewed example; it has not been executed as part of preparing this description.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "Vykos/Ouro-2.6B-RLTT"
revision = "82b9a74a0e384cd400f352cd4a6162d277638377"
tokenizer = AutoTokenizer.from_pretrained(repo, revision=revision)
model = AutoModelForCausalLM.from_pretrained(
    repo,
    revision=revision,
    trust_remote_code=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
).eval()
model.config.total_ut_steps = 4
model.config.early_exit_step = 3  # Zero-based index: read the fourth loop.
model.config.early_exit_threshold = 1.0
model.config.adaptive_compute = False

messages = [{"role": "user", "content": "Explain why the sum of two odd integers is even."}]
inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    generated = model.generate(
        **inputs,
        max_new_tokens=256,
        do_sample=False,
        use_cache=False,
        pad_token_id=tokenizer.eos_token_id,
    )

print(tokenizer.decode(generated[0, inputs.input_ids.shape[1]:], skip_special_tokens=True))

While the repository is private, authenticate through Hugging Face before loading.

Inspecting recurrent states

The supplied model forward supports return_per_loop_hidden_states=True and return_exit_pdf=True. These expose the states at loop boundaries and the exit distribution. Reading arbitrary physical layers within each loop requires hooks or equivalent instrumentation; loop-boundary outputs do not contain every intermediate block state.

with torch.inference_mode():
    outputs = model(
        **inputs,
        use_cache=False,
        return_per_loop_hidden_states=True,
        return_exit_pdf=True,
    )

loop_states = outputs.per_loop_hidden_states
exit_pdf = outputs.exit_pdf

These are research features, not calibrated confidence estimates or validated process rewards. Retaining internal states also adds memory beyond the weights.

Scope and evaluation

This repository distributes a research checkpoint and inspection runtime. It does not provide an independently reproduced RLTT leaderboard or an end-to-end retraining package. The archived provenance establishes the supplied checkpoint and conversion lineage; exact RL training seed, update and weighting variant remain unverified for this export.

The downstream papers primarily study frozen-backbone readouts and external interventions, with separately identified bounded LoRA experiments. Their probes, controllers and adapters are separate research artifacts, rather than features bundled into these weights. Their results belong to those experimental protocols rather than a general model capability score.

References

1. RLTT: Prioritize the Process, Not Just the Outcome: Rewarding Latent Thought Trajectories Improves Reasoning in Looped Language Models · arXiv · code.

2. Ouro: Scaling Latent Reasoning via Looped Language Models.

3. Operational Proto-Introspection: Paper · code.

4. Relational Preference Encoding: Paper and erratum · code and correction record.

5. Closing the Loop: Practical Training Recipes for Looped Language Models.

6. LatentHarness: Learning Latent Actions for Memory and Reasoning via Counterfactual Policy Distillation.

Acknowledgements

Thanks to Jonathan Williams for providing the Ouro-RLTT checkpoint weights.