Open Models Almanac
ModelsLaguna-S-2.1

Poolside

Laguna-S-2.1

What Laguna-S-2.1’s own documents say it is built from — every method with the sentence that describes it.

Parameters
118B / 8B active
Context
1M
Attention
sliding/global hybrid1:3 global : sliding-window (512) GQA, per-head softplus output gating
Experts
256 routed + 1 shared, top-10
Input
text
Licence
OpenMDW-1.1
Released
2026-07-21

Against the consensus recipe

Its documents state 5 of the 18 methods the field agrees on.

The recipe from the overview: the methods the most labs adopt, per stage. A missing one is something its documents do not say, not something the model lacks.
  1. Data curation

  2. Training objective

  3. Model architecture

  4. Optimization

  5. Post-training

  6. Inference & serving

Checked in its code

Its code shows 11 of the 19 architecture features checked — 7 of them are not stated in its documents.

Sources say what a lab chose to describe; the modeling code says what the checkpoint runs. Each feature below was put to a code verifier, and only the config values and source lines it cited that were found in the files are shown, linked to the line.

Read from Hugging Face Transformers (modeling_laguna.py, configuration_laguna.py) and config.json at revision 0f57314083, by anthropic/claude-sonnet-5 on 2026-11-07.

FeatureCodeIts documentsVerdict
Grouped-query attention in its codeadopted

Each layer projects queries at num_attention_heads_per_layer (48 or 72) while K/V use num_key_value_heads=8, shared via repeat_kv groups.

show evidencenum_key_value_heads = 8num_attention_heads = 48
self.num_key_value_groups = self.num_heads // config.num_key_value_heads
modeling_laguna.py · L334
self.k_proj = nn.Linear(
            config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
        )
modeling_laguna.py · L340–342
Multi-head latent attention not in its codenot stated

There is no kv_lora_rank/q_lora_rank low-rank latent projection; attention uses standard per-head K/V projections sized by…

show the whole verdict

There is no kv_lora_rank/q_lora_rank low-rank latent projection; attention uses standard per-head K/V projections sized by num_key_value_heads.

Sliding-window attention code only in its codenot stated

Layers whose layer_types entry is sliding_attention set self.sliding_window = config.sliding_window (512), restricting attention to a…

show evidence

Layers whose layer_types entry is sliding_attention set self.sliding_window = config.sliding_window (512), restricting attention to a local window via create_sliding_window_causal_mask.

sliding_window = 512layer_types = ["full_attention", "sliding_attention", "sliding_attention", "sliding_attenti…
self.is_local_attention = config.layer_types[layer_idx] == "sliding_attention"
        self.sliding_window = config.sliding_window if self.is_local_attention else None
modeling_laguna.py · L349–350
Interleaved sliding-window and global attention in its codeadopted

layer_types fixes a pattern of one full_attention layer followed by three sliding_attention layers, repeated across all 48 layers.

show evidencelayer_types = ["full_attention", "sliding_attention", "sliding_attention", "sliding_attenti…
mask_creation_functions = {
                "full_attention": lambda: create_causal_mask(**mask_kwargs),
                "sliding_attention": lambda: create_sliding_window_causal_mask(**mask_kwargs),
            }
modeling_laguna.py · L549–552
Indexer-selected sparse attention (DeepSeek Sparse Attention) not in its codenot stated

No indexer scoring module or index_topk/index_n_heads config keys exist; attention is dense GQA/sliding-window softmax attention only.

Linear-attention or state-space layers alongside full attention not in its codenot stated

All token-mixing layers in LagunaDecoderLayer use LagunaAttention (softmax attention); no linear-attention or SSM layer type exists in…

show the whole verdict

All token-mixing layers in LagunaDecoderLayer use LagunaAttention (softmax attention); no linear-attention or SSM layer type exists in layer_types or the code.

Gated DeltaNet layers not in its codenot stated

No gated delta-rule recurrent mechanism or linear_num_key_heads/linear_conv_kernel_dim config exists in this model.

Mamba-2 layers not in its codenot stated

No Mamba-2 SSM block or mamba_num_heads/ssm_state_size config exists; all layers are LagunaAttention.

Learnable attention sink not in its codenot stated

The attention forward and eager_attention_forward implementation have no learned per-head sink logit added to the softmax denominator.

Gated attention output code only in its codenot stated

Attention output is multiplied by a softplus (not sigmoid, but input-dependent) gate computed from g_proj before the output projection…

show evidence

Attention output is multiplied by a softplus (not sigmoid, but input-dependent) gate computed from g_proj before the output projection, per-head as configured by gating='per-head'.

gating = "per-head"
gate = F.softplus(self.g_proj(hidden_states).float()).to(attn_output.dtype)
        if self.gate_per_head:
            attn_output = (attn_output.view(*input_shape, -1, self.head_dim) * gate.unsqueeze(-1)).view(
                *input_shape, -1
            )
modeling_laguna.py · L400–404
QK normalization code only in its codenot stated

Queries and keys are each passed through a per-head RMSNorm (q_norm/k_norm) before rotary embedding and the attention dot product.

show evidence
self.q_norm = LagunaRMSNorm(self.head_dim, eps=config.rms_norm_eps)
        self.k_norm = LagunaRMSNorm(self.head_dim, eps=config.rms_norm_eps)
modeling_laguna.py · L352–353
query_states = self.q_norm(query_states).transpose(1, 2)
        key_states = self.k_norm(key_states).transpose(1, 2)
modeling_laguna.py · L373–374
Partial RoPE code only in its codenot stated

full_attention layers use partial_rotary_factor 0.5 (rotary applied to half of head_dim), while sliding_attention layers use 1.0 (full…

show evidence

full_attention layers use partial_rotary_factor 0.5 (rotary applied to half of head_dim), while sliding_attention layers use 1.0 (full rotary).

rope_parameters.full_attention.partial_rotary_factor = 0.5rope_parameters.sliding_attention.partial_rotary_factor = 1.0
partial_rotary_factor = config.rope_parameters[layer_type].get("partial_rotary_factor", 1.0)
        head_dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
        dim = int(head_dim * partial_rotary_factor)
modeling_laguna.py · L106–108
YaRN RoPE scaling code only in its codenot stated

The full_attention rope_parameters entry sets rope_type yarn with factor/beta_fast/beta_slow, and the rotary embedding dispatches to…

show evidence

The full_attention rope_parameters entry sets rope_type yarn with factor/beta_fast/beta_slow, and the rotary embedding dispatches to ROPE_INIT_FUNCTIONS for non-default types.

rope_parameters.full_attention.rope_type = "yarn"rope_parameters.full_attention.factor = 128.0
self.rope_type[layer_type] = rope_params["rope_type"]
            rope_init_fn: Callable = self.compute_default_rope_parameters
            if self.rope_type[layer_type] != "default":
                rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type[layer_type]]
modeling_laguna.py · L79–82
Layers without positional encoding (NoPE) not in its codenot stated

Every layer type (full_attention and sliding_attention) has a rope_parameters entry with a defined rope_type, so no softmax attention…

show evidence

Every layer type (full_attention and sliding_attention) has a rope_parameters entry with a defined rope_type, so no softmax attention layer skips positional encoding entirely.

rope_parameters.sliding_attention.rope_type = "default"
for layer_type in self.layer_types:
            rope_params = self.config.rope_parameters[layer_type]
            if rope_params is None:
                continue
modeling_laguna.py · L74–77
Mixture of experts in its codeadopted

LagunaSparseMoeBlock routes tokens via LagunaTopKRouter top-k=10 over num_experts=256 experts for layers marked 'sparse' in mlp_layer_types.

show evidencenum_experts = 256num_experts_per_tok = 10
_, selected_experts = torch.topk(scores_for_selection, self.top_k, dim=-1)
        routing_weights = routing_scores.gather(-1, selected_experts)
modeling_laguna.py · L170–171
Shared expert in its codeadopted

Each sparse MoE block includes a shared_experts LagunaMLP with intermediate size shared_expert_intermediate_size=1024 added to every…

show evidence

Each sparse MoE block includes a shared_experts LagunaMLP with intermediate size shared_expert_intermediate_size=1024 added to every token's output.

shared_expert_intermediate_size = 1024
self.shared_experts = LagunaMLP(config, intermediate_size=config.shared_expert_intermediate_size)
modeling_laguna.py · L223
hidden_states = hidden_states + shared_output
modeling_laguna.py · L235
Auxiliary-loss-free load balancing (selection bias) code only in its codenot stated

The router adds a learned e_score_correction_bias to routing scores only for top-k selection, not for weighting, matching…

show evidence

The router adds a learned e_score_correction_bias to routing scores only for top-k selection, not for weighting, matching DeepSeek-V3-style bias-based balancing.

scores_for_selection = routing_scores + self.e_score_correction_bias.to(routing_scores.dtype)
        _, selected_experts = torch.topk(scores_for_selection, self.top_k, dim=-1)
        routing_weights = routing_scores.gather(-1, selected_experts)
modeling_laguna.py · L169–171
Multi-token prediction layers not in its codenot stated

No num_nextn_predict_layers/mtp config key or MTP module exists in the config or code.

SwiGLU feed-forward code only in its codenot stated

Both the dense LagunaMLP and the expert MLP compute act_fn(gate_proj(x)) * up_proj(x) with hidden_act='silu' (SiLU = SwiGLU).

show evidence
down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
modeling_laguna.py · L142

token mixer 5

softmax attention 3

Softplus attention gating core

“with softplus attention gating and per-layer-type rotary scales”

grouped-query attention 2

Grouped-query attention core

“grouped-query attention”

Softplus-based per-head attention gating used

“and softplus-based per-head gating”

hybrid layer stacking 2

Hybrid Sliding-Window and Global Attention core

“Mixed SWA and global attention layout: 48 layers in a 1:3 global-to-SWA ratio (12 global attention layers, 36 sliding-window layers…”

Gated DeltaNet and full attention used

“+ 48 GA / 64 SWA Q-heads, 𝑘dense=1 (final ablation architecture)”

channel mixer 7

mixture of experts 7

Mixture of experts core

“M.1 and XS.2 are Mixture-of-Experts foundation models.”

Sparse expert activation core

“Efficient sparse architecture: Laguna S 2.1 has 118B total parameters and activates 8B parameters per token.”

Routed expert modulation used

“we adopted routed expert modulation”

expert routing 2

Token-choice routing with softplus gating core

“a token-choice router with softplus gating over 256 routed experts plus one shared expert”

Token-choice routing used

“LAGUNA XS.2 uses token-choice routing with 8 of 256 experts activated per token”

expert load balancing 1

Auxiliary-loss load balancing used

“For load-balancing, we use an auxiliary loss from Qiu et al. [66] across the non-padding tokens of the global batch.”

shared experts 1

Shared expert used

“plus a shared expert that processes every token”

positional encoding 2

Per-layer-type rotary position scales core

“with softplus attention gating and per-layer-type rotary scales”

Rotary Position Embedding used

“We employ Rotary Positional Encodings (RoPE) to encode positional information.”

5 more mentioned or evaluated
Dense gated attention with full RoPE and full gating evaluated

token mixer “Dense GA, full RoPE, full gating”

Gated attention with partial RoPE evaluated

positional encoding “+ GA Partial RoPE (50%)”

Per-Head Gating evaluated

sliding window attention “+ per-head gating, θswa = 10,000”

SWA-1024 (3:1 Interleaving) evaluated

sliding window attention “+ SWA-1024 (interleaved 3:1)”

SWA-512 evaluated

sliding window attention “+ SWA-512”

distillation objective 2

Quantization-aware distillation used

“To mitigate this, we used quantization-aware distillation (QAD) to recover quality; the quantized student was trained to match the traces…”

Hidden-state caching for KL distillation used

“We cache final hidden states of the teacher and reconstruct teacher and student logits through the frozen output head.”

optimizer 2

Muon core

“We use the Muon optimizer [39], specifically the Moonlight variant of Liu et al. [49], across all training stages”

Moonlight-style learning-rate scaling used

“we adopt Moonlight-style learning-rate scaling [49].”

learning-rate schedule 2

Warmup-Stable-Decay used

“we adopted a Warmup-Stable-Decay (WSD) learning rate schedule instead of cosine.”

WSD-specific scaling law used

“we therefore fit a WSD-specific scaling law by sweeping four MoE sizes”

training precision 2

BF16 mixed-precision training default

“We use BF16 mixed precision training throughout all stages with the master weights in FP32”

FP8-precision reinforcement learning used

“S 2.1 is also our first model where RL was done in FP8 precision, accelerating that part of the training.”

training stability 2

Exponential moving average (EMA) used

“we apply an exponential moving average (EMA) over the 10 most recent checkpoints”

Cross-replica model-weight hash consistency checks used

“we periodically hash model weights across replicas to assert that they remain bit-identical.”

training runtime 5

Automatic training recovery after failures core

“an in-flight recovery system detects hangs, NCCL failures, and node losses, replaces affected workers, and resumes from the latest…”

GPU-to-inference weight sync over GPUDirect RDMA used

“The weight sync uses NCCL point-to-point primitives over GPUDirect RDMA with no intermediate offload to host memory or remote object…”

Job-level eviction and reclaim used

“Capacity decisions are made at the granularity of jobs, not nodes.”

Pre-admission hardware stress testing used

“Pre-flight checks stress-test every node before admission”

Same-node sticky pod respawn used

“the scheduler prefers to respawn it on the same node it was previously bound to”

data sourcing 2

High-recall web-data curation used

“We shifted from a predominantly high-precision web pipeline toward a substantially higher-recall pipeline designed to preserve diversity…”

Streaming training-data ingestion with prefetched shared-memory batches used

“We stream training data rather than reading it from local disk.”

data filtering 9

Conservative model-based noise filtering core

“For LAGUNA XS.2, the primary rejection path is therefore model-based and deliberately conservative. The pipeline removes documents only…”

Multi-dimensional document quality scoring core

“Hence we decompose document quality into a set of independently learnable properties, which we then recombine into a composite…”

Quality-bucket sampling core

“The ranking pipeline therefore leverages model-based annotations to remove high-confidence noise, assigns continuous quality signals, and…”

Ranking retained documents by continuous contribution score core

“For the remaining documents, quality is treated as a ranking signal rather than fully filtered out. Documents are then sorted by a…”

Dense annotation of ambiguous low-quality data used

“We densely annotate this region within the N × I space”

PCA-based dimension selection for decorrelated quality signals used

“We keep Propella’s native rating ranges, use a PCA-informed subset of its dimensions to de-correlate signals, and then form the composite…”

Propella multi-property document annotation used

“The document tags are produced with Propella [36], an open multi-property document annotation model that exposes separate dimensions…”

Two-axis document-quality labeling by noise and information used

“we model document quality along two complementary axes: a noise axis (N) ... while an information axis (I) captures whether the document…”

One-task-per-repository diversity filtering optional

“optionally keeping a single task per repository to enforce codebase diversity”

deduplication 1

Snapshot-level fuzzy deduplication used

“Snapshot-level fuzzy deduplication is preferred because it gives higher performance on knowledge benchmarks.”

synthetic data 10

Dynamic multi-agent synthetic-data generation loop core

“where Hᵀ is a dynamic agent-interaction loop over orchestrators, generators, judges [92, 106], and per-step early-exit gates given a…”

Modular synthetic-data pipeline composition core

“We take a modular approach to synthesis: each pipeline composes from a small set of reusable components among six types”

Behavioral-constraint augmentation with synthetic system messages used

“We augment agentic tasks with synthetically generated system messages before trajectory generation.”

Large-scale targeted synthetic data rephrasing used

“We expanded the amount of usable training signal through targeted synthetic rephrasing at scale.”

Match synthetic-pipeline complexity to teacher capability used

“A task the teacher cannot solve in one shot becomes a source of biased generation, so we either decompose or strengthen the teacher.”

Metadata-conditioned synthetic generation used

“We hand our generator chain G anything we already know about the output or how to achieve it through supplying metadata, reducing the…”

Multi-stage synthetic-data generation cascade used

“Each Gᵢ transforms the previous output or emits metadata for later stages; the parenthesized V-gate prunes intermediate outputs.”

Synthetic data augmentation of organic pre-training data used

“We use synthetic data to complement our organic data sources. Synthetic data builds on top of those sources rather than replacing them”

Training-task generation from real commit history used

“Software-engineering tasks are mostly grounded in real code history: the largest source reproduces real commits (~38,000 tasks across…”

Two-sided test validation for synthetic coding tasks used

“Tasks are filtered with a two-sided correctness check that requires the gold solution to pass the tests and an empty solution to fail them”

data mixture & curriculum 5

AutoMixer core

“AutoMixer operates by training a swarm of proxy models, each trained on a different data composition.”

KL-regularized data-mixture optimization used

“To avoid unrealistic shifts toward a small number of dominant sources, we regularize the optimization toward the baseline prior”

Blind pairwise bucket-boundary calibration used

“For sampling, we define bucket boundaries by blind pairwise comparisons around candidate thresholds, so documents across a boundary are…”

Prior-constrained Dirichlet mixture exploration used

“Candidate mixtures are sampled as: x ∼ Dirichlet(αx₀) subject to additional constraints: ‖x − x₀‖₁ < ε”

RL task sampling proportional to unsolved rate used

“We drop tasks that were always solved or never solved, and sample the remaining tasks proportional to their(1− trace_rate)”

sequence packing 1

Sequence packing used

“We pack sequences shorter than the maximum sequence length into a single microbatch.”

tokenization 1

Subtoken-averaged special-token embedding initialization used

“For initialization, we use subtoken averaging [25, 72] — each new token’s embedding is initialized as the mean of its constituent…”

filed at the root 1

Two-stage post-training pipeline (SFT then RL) core

“The majority of what separates S 2.1 from the XS models comes from post-training, in two stages: an SFT stage that bootstraps capabilities…”

supervised fine-tuning 4

SFT bootstrapping with synthetic data used

“an SFT stage that bootstraps capabilities partly with synthetic data”

Evaluation-based early stopping during SFT used

“We run for three epochs of 40B tokens each, with early stopping based on evaluation scores.”

Frozen-network warmup for new special tokens used

“We then run a 100-step warmup phase where the full network except input embeddings and LM head layers is frozen”

Instruction-following fine-tuning used

“Instruction following: Malibu 2.1 went through additional training to understand and follow user instructions more accurately, especially…”

reinforcement learning algorithm 5

CISPO with length-weighted leave-one-out group-relative advantages core

“We train with a token-level REINFORCE surrogate combining importance-sampling-ratio clipping (CISPO [14]) with a length-weighted…”

Agentic RL task mix with a shared tool-use API used

“The RL prompt distribution spans three families that share a single tool-use API.”

RLCEF used

“Code editing: Malibu 2.1 was trained on an expanded set of RLCEF tasks, leading to better downstream performance at generating code edits…”

Tool-error step penalty used

“for every assistant step whose tool invocation led to the error in tool execution, we apply a small negative reward to exactly the tokens…”

Moonlight scaling optional

“Moonlight scaling [49] was deactivated during RL for LAGUNA M.1, but used for LAGUNA XS.2.”

reward modelling 4

Binary task verifier core

“For SWE-style tasks this is the repository’s own unit-test suite run against the agent’s patch; for terminal tasks it is the task’s…”

Deterministic reward-checking chain core

“Rewards are produced by a deterministic chain of checkers applied to every terminated rollout in the following order, with the first…”

Sparse terminal-verifier reward core

“long-horizon credit assignment is carried entirely by the binary verifier at the end of the trajectory, propagated to every token of the…”

Per-token tool-error reward shaping used

“This per-token shaping focuses credit assignment on the failing step and discourages long chains of malformed tool calls before falling…”

rollout & RL infrastructure 8

Token-in-Token-out (TITO) used

“We use a token-in, token-out (TITO) API design for the actors used in our RL training. This ensures that token IDs are stable across…”

Blocking in-flight rollout steps during weight updates used

“Weight updates are configured to block any in-flight rollout step on the update, so no single rollout step straddles a refresh”

Capping trajectory staleness used

“We also cap the staleness of trajectories used for training at 10 optimizer steps, which we empirically found to be a good corner between…”

Closed-loop multi-turn synthetic-data rollout used

“Closed-loop interaction; orchestrator decides flow and termination.”

Exact rollout-to-production chat-template alignment assertion used

“After every generation step we render the conversation history with this flag enabled and assert that the resulting string exactly matches…”

Long-horizon rollout budgets used

“More generous rollout budgets: substantially longer timeouts, more tokens per turn, and more turns per task than any model before it…”

Multi-harness rollouts used

“Multi-harness rollouts: the same prompts are rolled out in several agent harnesses, so the model learns behaviors that carry across…”

RL sandboxing with selective network blocking and artifact caching used

“Better sandbox infrastructure: RL moved to a new sandboxing service, enabling background processes, selective network blocking to shrink…”

agentic post-training 4

Agentic reinforcement learning core

“trained with reinforcement learning inside our agent harness”

Production-harness-matched reinforcement learning core

“The harness driving RL rollouts is the same one we ship in production: the policy interacts through the same tool API, chat template, and…”

Multi-harness trajectory training with native behavior preservation used

“We intentionally preserve native harness behaviors during data collection — including custom subagent spawning, context compaction…”

Seed-based terminal-task generation used

“Terminal tasks come from datasets where agents build unseen environments and tasks from a seed.”

mid-training & continual pretraining 1

Long-context extension via continued pretraining used

“The first sub-stage extends the context to 32K tokens; the second extends it to 128K tokens.”

decoding strategy 1

DFlash optional

“Speculative decoding: a trained DFlash draft model is available for lower-latency serving”

reasoning control 5

Interleaved thinking core

“Native reasoning support: interleaved thinking between tool calls”

Thinking mode default

“Native reasoning support: You can run requests with thinking off or with max thinking. Max thinking is enabled by default”

Max thinking mode with self-set compute budget default

“Laguna S 2.1 has two thinking modes: off and max (enabled by default) where it determines the right thinking/test-time compute budget for…”

Persistent reasoning history used

“We train with persistent thinking history, where all prior reasoning blocks remain visible in the context during each generation step.”

Per-request thinking control optional

“per-request control via enable_thinking”

KV cache management 1

KV-cache reset on weight synchronization used

“Weight broadcasts trigger an inference-side KV-cache reset, so the cache can never mix tokens encoded under different weight versions.”

inference quantization 8

FP8 KV-cache quantization used

“storing the KV cache in FP8 roughly doubles the number of concurrent trajectories a single replica can carry”

AWQ INT4 weight-only quantization used

“For INT4 weight quantization (W4A16), we applied AWQ using a calibration set of 128 long-context agentic trajectories. This approach…”

FP8 KV-cache quantization with amax-based scaling used

“The KV cache was quantized to FP8 using amax-based scaling with a calibration dataset of 128 long-contexts agentic traces.”

FP8 W8A8 quantization with dynamic activation scaling used

“For FP8 quantization (W8A9), we used a amax-based quantization scheme with dynamic activation scaling that does not require calibration.”

Layer-wise mixed INT4/INT8 quantization used

“We adopted a mixed-precision quantization strategy: the first 30 layers were quantized to INT4, while the final 10 layers were quantized…”

MoE-layer quantization used

“We quantized the model’s MoE layers to FP8, INT4, NVAP, and the KV cache to FP8.”

SpinQuant R1 rotation preprocessing used

“We found that using SpinQuant R1 rotation improved the quality of FP8 quantization without working any runtime overhead, and therefore…”

TRT-LLM inference optimization to NVFP4 on Blackwell used

“Poolside worked with NVIDIA to optimize inference from TRT-LLM serving to NVFP4 on Blackwell, down to a single DGX Spark.”

inference scheduling 1

Envoy proxy with custom orchestrator used

“To manage traffic across Atlas deployments we run an Envoy-based proxy paired with a custom orchestrator that owns session management and…”

context management 1

Preserved thinking history used

“keep reasoning_content from prior assistant messages in the message history”

agentic scaffolding 4

Current-turn-only reasoning-mode detection used

“Our parser instead scans only the current turn’s content, so prior reasoning spans in the conversation history do not short-circuit the…”

Multi-token streaming-delta handling used

“In practice, deltas can contain multiple tokens — for example, under speculative decoding or when vLLM’s single-slot output collector…”

XML-tagged tool-call format used

“Laguna S 2.1 is guided to use a tool call format where tool calls are marked by XML-like tags:”

Checkpointing for rollback optional

“If this occurs, use the checkpointing feature to roll back its changes.”

1 more mentioned or evaluated
Task-specification prompting mentioned

agentic scaffolding “Give Laguna M.1 a clear task with the specific outcome you want. Include relevant context such as file paths, error messages, failing…”

Not used 2

Reasoning effort configuration availability not used

reasoning control “We are releasing this model without user-configurable effort (low-medium-high) control today to get Laguna S 2.1 into the hands of users…”

On-the-fly block-wise FP8 weight quantization not used

inference quantization “we quantized the inference-audit weights to FP8 with an in-flight block-wise copying: weights were re-quantized on the inference replica…”

filed at the root 1

Shared codebase for research and production used

“maintaining a single code base for research and production ... gives us a crucial advantage”

inference engine 1

Atlas inference library used

“Atlas serves every downstream consumer: automated evaluations, internal inference, customer-facing production traffic, but also crucially…”

training framework 2

Dagster core

“We use Dagster [19] as the central control plane to navigate the directed acyclic graph (DAG) of assets”

Experiments as Code core

“All inputs and configurations to any run ... are expressed as code committed into a single repository.”

infrastructure service 5

End-to-end lineage tracking core

“Maintaining a DAG of inputs, runs, and artifacts allows us to surface the complete lineage of any model or artifact in both directions”

HTTP/HTTPS sidecar proxy used

“We run a sidecar for HTTP and HTTPS requests to handle these requests instead with a fallback to the default httpbin.org endpoint.”

In-house batch scheduler used

“We replaced it with an in-house batch scheduler purpose-built around three observations”

Model Factory used

“Our internal platform for research and engineering, which we refer to as the Model Factory, allows us to industrialize the model…”

Vendoring external dependencies used

“We vendored (stored copies in internal storage) all external dependencies for tasks fix-ocaml-gc, reshard-c4-data, build-cython-ext…”

filed at the root 5

avg@k used

“We report mean pass@1 averaged over multiple attempts per task (avg@k), with k per benchmark listed below.”

Diverse benchmark validation for quantization used

“Using a mixed set of benchmarks to properly validate that the quantization process does not introduce any unintended side effects…”

Evaluation trajectory release used

“For every benchmark score we publish today, we are releasing full trajectories for every trial in the final evaluation set at…”

Four-run mean pass@1 used

“To address this, we run each benchmark four times and report the mean pass@1 across the four runs.”

Official-source external baselines used

“we report external model baseline scores only from official release blog posts by the authors or equivalent”

benchmark 1

Execution-grounded evaluation used

“Execution-grounded evaluation: benchmarks where each task requires a real software environment that compiles, runs, and tests the model's…”

evaluation harness 3

Harbor Framework used

“using the Laude Institute's Harbor Framework with our agent harness”

Automatic in-flight checkpoint evaluation scheduling used

“We schedule configurable evaluations automatically for every training experiment, run against in-flight checkpoints which execute on Atlas.”

Pool agent harness used

“evaluations run using pool, Poolside's agent harness, so researchers and developers can reproduce the results on their own hardware”

judge 3

Decompositional instruction-following judge used

“We developed a dedicated IF judge that decomposes a system message into a list of independent behavioral requirements and scores each…”

Human-calibrated LLM-as-a-judge used

“Using an LLM as a Judge (LLMaaJ) calibrated with human labeled trajectories, we tag solutions that potentially reward hack after every eval.”

Reward-hack judge used

“we have developed a reward hack judge to detect these specific cheating strategies, which we ran post-hoc-on all candidate evaluation runs…”

filed at the root 5

Automating repetitive research work core

“Another core principle of our Model Factory is to minimize the need for repetitive and mechanical manual work as much as possible…”

Agentic experiment workflows used

“Today we use agents to design and run ablation experiments, monitor runs and debug issues, and compile and analyze experiment results.”

Patching benchmark images to remove git-history leaks used

“we patched the base task images to remove the git history leak for all affected code_path benchmarks”

Prompt addendum against direct online solutions used

“To address this we added a small prompt addendum to the user prompt instructing the model to not use direct solutions found online.”

Unique run identifiers used

“Each run is tracked with a unique ID”

unfiled 23

Agentic edit-and-validate loop (read, edit, run checks) core

“Read files and folders to understand project structure. Edit files. Run programs, such as linters, compilers, tests, or local services, to…”

agentic repository installation task used

“New for S 2.1 is agentic repository installation: given a repository, install every dependency and get the test suite running.”

automated agentic research loop for software optimization used

“We then ran Laguna S 2.1 in an automated research loop that fed each result back to it and pushed it to keep improving.”

benchmark-instrumented target code for agent optimization used

“For this task, we instrumented the harness with benchmarks so the model could see exactly where the time and memory went.”

Configuration-flag promotion of validated components to production used

“a successful innovation can be promoted into production by simply flipping a configuration flag.”

Fixing dependency drift in benchmark tasks used

“Fixed dependency drift on tasks: build-pmars, crack-7z-hash, mteb-leaderboard, mteb-retrieve, rstan-to-pystan, dna-assembly, dna-insert…”

Fixing verifier selections in benchmark tasks used

“For SWE-Bench Pro we made edits focused on fixing verifier selections and the previously mentioned reward hack vulnerabilities.”

Ignoring known teardown flakes in evaluation used

“If the known teardown flake occurs with the exact signature seen under the golden patch, and is the only failure, we ignore it.”

In-task retries for flaky external services used

“We added in-task retries on components that rely on external services which are known to be flaky”

one-change-at-a-time benchmarking with measurable-wins retention used

“We set strict rules: one approach at a time, benchmark after every change, keep only what measurably wins.”

open-weight model release used

“the weights are available today on Hugging Face under an OpenMDW-1.1 license”

Parabola fit in log10 learning rate space to find optimal learning rate used

“For each (𝑁, 𝐷 ∈ {60, 120, 240, 480, 960} B) we fit a parabola in log10(lr) space and take the vertex as lr⋆(𝑁, 𝐷)”

Per-cell power-law fits for loss vs tokens used

“Per-cell fits. Per-(𝑁, lr) power-law fits 𝐿(𝐷) = 𝐿 0 + 𝐴 𝐷 −𝛾 across the five cooldown points are shown in Figure8”

Pinning dependency versions to avoid drift used

“To fix this we pinned to setuptools^=58.0.0.”

Publication of unedited evaluation trajectories used

“Poolside team shared three unedited trajectories to show behavior rather than scores.”

sandboxed agentic benchmarking on a Harbor fork with step limit used

“All Laguna S 2.1 agentic benchmarking was completed using our internal fork of the Laude Institute's Harbor Framework with our agent…”

training objective for persistence and verification behaviors used

“What we've done in this model is not necessarily add more intelligence, but improve the behaviors that lead to a more capable model: more…”

WSD optimal learning rate scaling law used

“Supporting figures and tables for the WSD optimal-LR scaling law described in Section3.1.1.”

cross-provider failover routing optional

“When an error occurs in an upstream provider, we can recover by routing to another healthy provider, if your request filters allow it.”

Multi-precision weight formats (BF16/FP8/INT4/NVFP4) optional

“Poolside team publishes weights in BF16, FP8, INT4, and NVFP4”

3 more mentioned or evaluated
Checking for agent-generated test scripts before committing mentioned

“Malibu Agent can sometimes create test scripts to validate its changes, but forget to delete them. Check to make sure you do not commit…”

Incremental task decomposition for agent prompts mentioned

“If Malibu Agent is unable to solve an issue, break your request down into smaller, incremental changes, or be more direct. For example…”

Planning with the model for self-contained tasks mentioned

“Keep tasks self-contained by planning with the model.”

Further reading

Picked by hand, not extracted: where to read more, not evidence for anything on this page.

Sources

The curated source list for this model. "not fetched" means the URL is recorded but its text was not read in the current run.

↑