SRE-1 Paper

SRE-1: Dominating the Pareto Frontier of Production Investigations with a 27B Model

ResolveAI Labs

November 18, 2026

Figure 1: SRE-1’s configurations dominate the frontier of pass rate against cost. Our test set is 49 real, complex cases from live production, each run five times. We traverse the frontier by varying context budget and ensembling strategy. Confidence intervals are 95%, and reasoning effort is denoted by l, m, h, xh. Hover over points to see details and click “log|linear” or “pass rate|score” to toggle the axes. We dropped a few rollouts (14/6,615) due to harness or serving errors.

Abstract

We introduce SRE-1, a 27B model trained with reinforcement learning to find the root cause of production alerts. On 49 difficult live production cases, SRE-1 dominates the Pareto frontier of pass rate against cost: at every budget from our cheapest configuration upward, it has the highest pass rate of any model we tested. Reinforcement learning (RL) raises the pass rate of a single investigation more than fivefold, from 6.9% for the base model to 38.8%. An ensemble of five SRE-1 investigations matches Fable 5.2, the strongest frontier model we measured, at a 71% pass rate while costing 37% less. SRE-1 also outperforms frontier models at synthesizing saved investigations, which is why its ensembles improve on a single investigation. We train on several types of realistic internal environments with our production investigation tools. Starting from Qwen3.8-27B, we train with a modified CISPO objective for 200 steps on up to 512 GPUs, over 1,549 unique incidents, and select SRE-1 from the resulting checkpoints.

Introduction

When a production alert fires, an on-call engineer must find what broke and why, and fix it before a small issue grows into an outage [6, 20]. It is important to move quickly to contain any potential damage, and a wrong analysis could send engineers down the wrong path. Unplanned downtime is estimated to cost Global 2000 companies $600B annually [45]. LLM agents have recently begun to help with this work [10, 14]: given an alert, an agent queries the same observability, code, and change-tracking tools an engineer would, and proposes a root cause. To be useful, its answer must be correct, arrive while the incident is still unfolding, and be cheap enough to run on many alerts.

Why production is hard for agents

Figure 2: An alert is typically a query, a threshold, and a duration, and it names a symptom. Illustrative example.

Many tools. Real production software systems are vast, and the information required to troubleshoot them is siloed across hundreds of tools, including telemetry (logs, metrics, and traces), code, deploy history, internal wikis, tickets, and incident channels, each queried in its own language. An agent cannot gather everything first and reason afterward; it must carefully plan each query.

Practically infinite data. Logs and metrics cannot be read exhaustively or fit into a model’s context window, even the 1M-token window we use. To give a sense of volume, Shopify processed 11 TB of logs a minute at peak in 2025, for example [44]. The model must write targeted queries and keep only what bears on the incident.

High rate of change. Production environments change so frequently that their state an hour or a day ago does not establish their state now; all documentation is perpetually out of date. Google SRE attributes roughly 70% of outages to changes [6], yet changes occur almost constantly, so a change shortly before an alert may be coincidental. Earlier snapshots and documents cannot establish the system’s state at alert time. The agent must reconstruct that state from records and identify recent changes that could have caused the alert.

Misleading symptoms. Alerts fire on symptoms (Figure 2) [38]; a lasting fix requires tracing its cause [6, 20]. An investigation that stops at the first plausible explanation will often be wrong, and the agent must trace the symptom back and rule out rival causes.

Tribal knowledge. Every production system has its own tribal knowledge: undocumented know-how held by employees or that exists only in the code or storage. Further, incidents differ wildly in their triggers and fixes, both within a system and across systems (Figure 3), so a model cannot follow a fixed playbook and must investigate systems it has never seen.

Figure 3: Our taxonomy: incidents differ in where the fix lies, what triggered them, the type of fault, and how far the root is from the symptom. N is the number of the 1,503 live-tool incidents in our dataset that fall in each category (Figure 9 splits them by source). Hover over a category for an example.

Root-cause analysis with SRE-1

Figure 4: SRE-1 investigates a company’s context in depth to identify the root cause of an alert or incident and expresses it as a causal chain: A caused B, which caused C. Confidence is the model’s own estimate of how closely its chain matches the ground truth. Real chains are often longer and cite many pieces of evidence.

We present SRE-1, a 27B dense model trained with reinforcement learning (RL) from the released Qwen3.8-27B weights [39]. Training uses real internal, snapshotted internal, and synthetic incidents through production tools and integrations. From 200 training steps, we select the best checkpoint on validation incidents at the 1M-token window we serve, using 4× YaRN scaling [35] beyond training windows of at most 262k tokens.

Problem setting. An agent starts from an alert and a knowledge graph of the environment, then queries the systems engineers use day to day through more than 400 tools across about 60 integrations (Figure 4). If the alert is misconfigured, the agent must be able to conclude that the system is healthy and the monitor needs retuning.

Scoring. The agent submits a causal chain, scored against a reference chain by LLM judges calibrated with on-call engineers; a score of 0.8 or more is a pass. We count A as a cause of B only if A came first, a mechanism links them, and B is missing wherever A is missing (the counterfactual condition [27]). In our illustrative incident (Figure 2), the 13:42 deploy removed write batching from order-writer and saturated the database’s write queue. Clients timed out, their retries added load, and the alert fired at 14:02. Instances on the old version kept batching, and the 13:30 node upgrade was ruled out because database replicas on nodes not yet upgraded also slowed.

Results. On our test set of 49 challenging live production cases, each run five times in our production harness, SRE-1’s configurations dominate the Pareto frontier of pass rate against cost (Figure 1, Table 8). RL raises single-investigation pass rate from 6.9% for the base model to 38.8% for SRE-1; five-investigation ensembles pass 71%, matching Fable 5.2 at xhigh effort for 37% less cost. SRE-1 also outperforms both Opus 5.5 and Fable 5.2 at xhigh on offline synthesis of saved evidence (Section 6.2). RL in realistic environments is enough to make a small model competitive on these tasks.

Most public work on SRE agents has focused on evaluation [9, 11, 21, 22, 52]. Most public reinforcement learning (RL) recipes train coding agents [8, 12, 13, 26].

SRE benchmarks. Most SRE benchmarks inject faults into one to five applications and grade the answer against the known cause. AIOpsLab [9] has 48 problems on two applications, where agents averaged 6.4 to 14.7 steps. ITBench [22] has 42 SRE scenarios, and SREGym [11] has 90 problems on applications of up to 40 microservices, with a 30-minute timeout. ORCA-bench [21] records over 50 GB of telemetry from one 19-microservice application, and OpenRCA [52] pairs 335 failures with 68.5 GB and lists the candidate answers in each prompt. Earlier work fine-tuned or prompted LLMs on Microsoft incidents [1, 10]. We train on internal and synthetic incidents through production tools, with a median of 63 tool calls per training rollout.

SRE agents. Scout [14] trains an SRE model on simulated investigations. Our most realistic training environment is our own production environment, which the agent queries through read-only live backends.

Reinforcement learning for long-horizon agent tasks. SkyRL-Agent [8] keeps reasoning and token ids across turns. PipelineRL [36] and AReaL [17] overlap sampling and training with in-flight weight updates. Inkling [46] randomizes tool sets and schemas during training, and DeepSWE [26] masks rollouts cut short from the loss. Our training combines token preservation, asynchronous training, and variation in the tool interface.

Domain-specific post-trained models. Composer 2 [12] trains fully asynchronously in a harness that matches production. Composer 2.5 [13] localizes credit with textual feedback. SRE-1 likewise matches its training harness to production and assigns credit per turn and per token.

RL algorithms. ScaleRL [23] studies which RL design choices continue to help as compute scales and, following MiniMax-M1 [30], shows that keeping the LM head in fp32 substantially improves RL performance. CISPO [30] clips importance weights while preserving token gradients. GRPO [43] divides advantages by each group’s reward standard deviation; Dr. GRPO [25] identifies the resulting difficulty bias, which inflates advantages on very easy or very hard prompts. DAPO [54] drops groups whose rollouts all score alike. ScaleRL inspired our modified CISPO objective (Section 4.1).

Training Environments

Most alerts lack postmortems and therefore answers to grade against. Their telemetry expires within weeks, while later commits, tickets, and chat can reveal the cause and fix. We train SRE-1 on two tasks (Figure 5): (a) live-tool investigation, where it investigates by issuing live queries to production tools, and (b) offline synthesis, where it writes the causal chain from evidence an earlier investigation already gathered, with no access to production tools. Our dataset of 1,503 live-tool incidents exposes the production tool surface as it stood when the alert fired. No evidence is gathered in advance, so the model must decide what to query. The training run started on an earlier 904-incident dataset and later upgraded to the 1,503-incident dataset after step 125 (Table 4). Offline synthesis targets a quarter of each training batch and draws on 7,716 problems built from 1,774 saved investigations. We follow training on a validation set of 101 incidents held out of training, 57 of them from environments held out of training. SRE-1 is the best checkpoint of the run on the validation set, at step 110.

Figure 5: Training covers both halves of an investigation: gathering evidence through production tools, and reasoning over evidence already gathered. Investigation has three tool interfaces, and we balance them and offline synthesis equally, as if they were four tasks; the exact counts vary in each step.

Every tool call runs a real query against real or captured data. We also tried simulation, in which an LLM wrote a response to each query we had not recorded, based on the responses we had. We discontinued it because, in our tests, its fidelity was poor and hard to improve. Tool calls in our environments also fail the way they do in production, for infrastructure reasons such as timeouts, rate limits, and unhealthy backends, and we keep those failures: 18.1% of training investigations had at least one failed tool call (Appendix A). We inject no tool call failures, and we never drop a rollout because a production tool failed.

Sources of live-tool incidents

Figure 6: The base model fails production incidents far more often than synthetic or licensed incidents, so the dataset needs them for hard incidents. Each bar is the share of a source’s incidents that the base model never solves in four rollouts (1,243 incidents from an earlier version of the dataset).

We combine four sources of incidents (Table 1), and Figure 9 breaks the dataset down by kind of incident. Live incidents and incident replays are real and the hardest for the base model (Figure 6), but they come without answers: the root cause must be established before we can train on them (Section 3.2), and they are slow to prepare. Synthetic environments have known answers, since we plant their faults ourselves, but planted faults are easier to detect. Licensed environments from external vendors (8% of incidents) add a few systems built by others. RL raises the validation score on all four, by 0.13 to 0.22 from the base model to SRE-1 (Figure 7).

Live
incidents
Incident
replays
Synthetic
environments
Licensed
environments
Offline
synthesis
OriginInternalInternalSyntheticVendorInternal
Real fault✓✓✗✗✓
Closeness to productionHighMediumLowLowHigh
Answer known by construction✗✗✓✓✗
Make telemetry tool calls✓✓✓✓✗
DiversityMediumHighMediumLowHigh
VolumeMediumMediumMediumLowHigh
CostLowMediumMediumHighLow
Setup effortMediumHighMediumMediumLow
Table 1: What each training environment provides. Origin: internal incidents come from our own production environment, synthetic environments are built in-house, and vendor environments are licensed. Real fault: the fault happened in a production system rather than being planted. Closeness to production: how closely the environment reproduces the production systems and tools that SRE-1 investigates. Answer known by construction: the reference chain is known exactly rather than reconstructed by our multi-agent system. Diversity: how varied the systems behind the problems are. Volume: how many problems the source can supply. Cost: dollars per problem. Setup effort: the work it takes to turn one incident into a training problem. Green marks the better end of every row, so low cost and low setup effort are green.

Figure 7: RL raises the validation score on every source, including the two from production. (a) The training reward understates learning: once the model reliably solves a prompt, the curriculum holds it back, so later batches are harder. Its dip near step 145 has two causes: the dataset upgrade at step 126 added harder incidents, and for steps 142 to 149 the reward put more weight on speed bonuses that most rollouts do not earn. We therefore read progress from (b), the validation score. The open dots at step 0 are the base model, and the bold numbers are the paired gains from the base model to SRE-1.

Live incidents (23%). These are internal to our company: Resolve’s agent investigating issues in Resolve’s own production environment, a rich source of incidents and our most realistic environment. Our internal production environment cannot establish representativeness by itself. We therefore also evaluate on a test set run through live production integrations, where SRE-1 retains its gains over the base model (Section 6.1). We use our agent heavily in our own environment, and we keep its investigations together with the feedback that our engineers gave while working each incident with it in chat. Because we own this environment, we can snapshot all of the telemetry behind each incident and re-investigate it with live tools long after it happened; this is what separates live incidents from incident replays, which serve a partial capture.

Incident replays (34%). We preserve incidents from our own internal production environment while their data can still be queried, then replay them during training so that new queries from an investigation can still be answered after the original telemetry expires.

Figure 8: Information leakage in early synthetic environments: fault identifiers were exposed through metric names. This environment exported its planted fault as a metric named after it (top), and the investigating agent read the answer from the monitoring (bottom); its answer scored 0.96. Our leakage check now excludes such incidents. The rollout is real, trimmed where marked, with label values changed.

Synthetic environments (35%). In a synthetic environment the fault is planted, so the answer is known by construction and no reference chain has to be reconstructed. Agent swarms build each environment, with services, simulated traffic, and vendors, and the same agents then plant a fault, investigate it, and write it up. The environments are designed to be as complex as real production systems: for example, one runs 22 services and 28 scheduled jobs over several data stores and queues, and any of them can be made to fail. The agents that built the faults knew the answer, and some accidentally left it in the environment (Figure 8).

To check that the dataset resembles real on-call work, we used LLMs to label every live-tool incident with the 24 categories of the taxonomy in Section 1.1 (Figure 9). The labelers agree with human reviewers on 89% of labels. The four sources are complementary. Incident replays hold the largest shares of roots in third-party systems and platforms and of outages; live incidents, of workload-driven failures; licensed environments, of faults from the team’s own recent changes; and synthetic environments, of failures with no identifiable trigger.

Figure 9: The four sources cover different kinds of incident. Each cell is the share (%) of a source’s live-tool incidents in the 1,503-incident dataset (340, 506, 530, and 127 incidents) that falls in a category. An outline marks the source with the largest share. Shares are rounded and incidents that fit no category are left out, so a group need not sum to 100.

Reference chains

Expert annotation is slow and difficult to scale. Production evidence expires faster than experts can write reference chains, leaving many incidents unusable while they await annotation. We build reference chains with a multi-agent system. For each production incident, it establishes the chain from the raw evidence and audits each link against primary records. This process requires no expert time and labels most of the incidents it is run on. We compared its chains with expert-written chains on 27 incidents. Our evaluation team of expert SREs judged the system’s chain as good as an expert’s or better on 26. Scoring the same rollouts against either reference barely changes their mean score (row 33 of Table 6). Synthetic incidents have reference chains known by construction and do not require this process.

Leakage and time pinning

Figure 10: Every tool returns results consistent with the environment at the time of the alert to prevent information leakage from subsequent records. Records written after the alert are hidden or rolled back, and query windows end at the alert. Positions are illustrative.
Figure 11: Every candidate incident must pass our quality checks before it can train, and leakage excludes the most. An incident that leaks its answer rewards a shortcut. Of the dataset’s 1,663 candidates, 1,503 passed every check, and the figure shows the 160 excluded incidents by check.

Training on historical incidents introduces a risk of information leakage from records created after the incident. By the time the model investigates an incident, often the fix has been deployed and the cause documented in commits, tickets, and chat. Access to these records trains the model to retrieve documented answers in place of investigating the incident. We use time pinning to prevent leakage by making every tool return results consistent with the environment at the time of the alert (Figure 10). Implementing time pinning is difficult because each data source represents time differently and provides indirect access to future states. For example, in one replay an agent found the hash of a later commit and requested its contents. It retrieved the fix for its own incident, took the root cause from that change, and scored high against our reference chain. Out of our production tool set (hundreds of tools), we either added time pinning or dropped the tool for training. Information leakage can also occur through record contents, including commit messages and metric names that identify the root cause (Figure 8). We apply several quality checks to every incident in the dataset (Figure 11; Table 5). These checks retained 1,503 of 1,663 candidates, and leakage was the most common reason for exclusion.

Auxiliary task: offline synthesis

Figure 12: Offline synthesis trains re-investigation, and an ensemble applies the same skill to several investigations. SRE-1 investigates saved evidence in one read-only folder and returns a chain citing its files (top). We judge the answer against a reference outside the folder, inaccessible to the model. We combine five investigations into one answer through a tree of syntheses (bottom); this is the ×5 point in Figure 1.

Offline synthesis is a second task that we train alongside live-tool investigation. The model receives an alert and a read-only folder containing what an earlier investigation saved: its tool calls, their full outputs, and the runbooks it consulted (Figure 12). From that evidence alone, it must construct the best causal chain it can, citing the files. Saved investigations from our own internal production environment provide training examples for reasoning over evidence, a skill also used in live-tool investigation. Rendering each in up to six variants gives 7,716 problems from 1,774 investigations (Table 2). The same task supports ensembling by combining independent investigations into a more accurate answer [49, 50] (Section 6.1).

ComponentSetting
InputThe alert and a README of the saved evidence; in half of rollouts also a budgeted index of the original agents' tool calls (10K–30K tokens)
Toolbash in a sandbox with no network; /workspace read-only, /tmp writable; 30 s per command; 12,000-character previews with full output saved to a file
OutputA causal chain whose evidence entries each cite numbered lines of a saved file and give the reasoning; a confidence that predicts the chain's own score
TerminationA valid final answer, or an exhausted context of about 154K–162K tokens
Corpus1,774 training investigations, rendered in up to six variants each (7,716 problems), of which the run served 1,295; a synthesis validation set of 73 held-out investigations, one problem each. The rendered corpus holds 371,820 reference citations
Table 2: Settings of an offline-synthesis problem.

Reinforcement Learning

We train for 200 steps from the released weights of Qwen3.8-27B [39]. SRE-1 is the checkpoint at step 110, which we chose on the validation score (Section 4.5). We later changed the recipe to trade some accuracy for faster investigations. Each step trains on one batch of 2,048 rollouts, 32 rollouts for each of 64 prompts. Appendix B shows one such batch interactively.

Formally, an investigation starts from an alert q in an environment that holds the incident’s telemetry, tools, and code at the alert’s revision. Each action ak, or turn, is one model response, with reasoning and zero or more concurrent tool calls that return observations yk. Actions are sampled from the policy

(1)ak∼πθ(⋅∣q,a1,y1,…,ak−1,yk−1),

and the final action submits an answer c, the ordered causal chain with evidence citations. A judge scores c against a reference chain c⋆ and returns a score s∈[0,1]. For each prompt, the incident as the policy receives it with its alert, tools, and harness, we sample a group of G rollouts. Each policy update is a step. A rollout’s reward R is built from its score s (Section 4.2), and its advantage is its reward minus the mean reward of its group.

Objective

ScaleRL [23] compares RL objectives for language models at scale, and we adopt its choice, CISPO [30], which weights each token’s gradient by a clipped, stop-gradient importance ratio instead of clipping the update. However, the token probabilities computed by the trainer and by the sampler, which generates the rollouts, are rarely exactly equal, and recent systems report that a few tokens with extreme ratios destabilize training unless they are masked [24]. Inspired by these results, and by the double-sided masks of IcePop [24] and MiMo-V2.6 [51], we add a mask to CISPO. With πθold the sampling policy that generated token oi,t of rollout oi and ri,t(θ) the importance ratio, we maximize

(2)J(θ)=∑i=1Nwi∑t=1|oi|Mi,tsg(min(ri,t(θ),ϵmax))A^i,tlog⁡πθ(oi,t∣q,oi,<t),ri,t(θ)=πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t),Mi,t=1[α≤ri,t(θ)≤β]
Figure 13: Ratio-mask ablations: a narrower band lowers the validation score, and the mask lowers trainer–sampler KL divergence 38-fold during a spike. (a) Score on an earlier validation set of two runs forked from the same checkpoint at step 70 that differ only in the band [α, β]: wider [0.8, 1.25] and narrower [0.92, 1.08]. Both are far narrower than SRE-1’s band, [0.2, 5]; we tested them to reduce the mismatch. By step 85 the narrower band scores 0.049 lower [0.032, 0.066], paired over 80 incidents, because it drops more tokens. (b) KL divergence between trainer and sampler (k3 estimator) through a spike in an earlier run with our band, over all tokens and after masking.

Here N is the number of rollouts in the batch, sg stops the gradient, oi,<t is the rollout’s context before token t, A^i,t is the advantage, centered within each group of G=32 rollouts and scaled per environment, wi gives each rollout equal total weight regardless of its length (Appendix C), ϵmax is CISPO’s cap, and Mi,t masks tokens whose ratio leaves the band [α,β]=[0.2,5]. Since the trainer steps once per batch, ri,t reflects only trainer–sampler mismatch and at most 2 steps of staleness. We set ϵmax=5, the band’s upper edge, so inside the band a token keeps its full weight ri,t, and outside the band it is dropped. The clip therefore never binds, and the loss reduces to a masked importance-sampling policy gradient. We ran learning-rate ablations across a range and selected the optimal value.

The mask improves RL stability: during a spike, the KL divergence between trainer and sampler (k3 estimator [41]) was 38 times lower with the mask than without it (Figure 13b). For ratio masking [24, 51], our ablation found that the narrower tested band discarded more tokens and lowered the validation score (Figure 13a). Following recent work [54] we don’t use a KL term, and an earlier ablation showed that adding one harms performance (Table 6).

Training involves a very large number of design decisions, which we addressed systematically with extensive A/B ablations. Appendix D shows all 33 in full, including both positive and negative or neutral results.

Reward

The reward is a weighted sum dominated by an LLM judge’s score of the submitted causal chain against a reference chain. We use a continuous judge score to give partial credit on challenging incidents, providing a learning signal even when no rollout passes (row 9 of Table 6). We add smaller-weighted terms to encourage faster investigations, and to discourage specific problematic tool-call behaviors that we observed in training.

Figure 14: The 13 reward judges differ widely in strictness, which is why one judge scores every rollout in a group. Each dot is the share of the rollouts a judge graded that it scored 0.8 or more. Color marks the provider, and letters tell one provider’s models apart.

Reward hacking. A well-known problem in RL is that a policy learns to score better with the judge without getting better at the task [19]. We saw this in early runs. The policy restated the alert as its first causal link, listed ruled-out causes nobody had proposed, reversed causal order, and cited a README it never opened. We fixed these exploits in the citation check or the judge. The judge also caps scores for chains offering several candidate causes or marking their mechanism as unconfirmed. We resolve every citation against its source; of 3.8 million citations in the trained rollouts, 98.2% resolved.

Measured training gains depended on the judge’s model family, with errors correlated within providers but not across them. Each group is therefore scored by one judge drawn at random from 13 spanning several API providers and effort settings. This keeps rewards comparable within a group despite wide differences in judge strictness (Figure 14).

Dense credit assignment

Standard policy-gradient RL gives every token of a rollout the same advantage, so mistakes within an investigation that reaches the right answer are rewarded with it. In an earlier run, high- and low-reward rollouts made tool mistakes at the same rate; up to 24% of rollouts exceeded the limit of ten calls per turn, with one issuing 1,458 calls in a single turn. Up to 12% produced repetition loops or incoherent text (Figure 15).

Figure 15: An earlier run diverged when we tried using a global reward term to encourage parallelism. With a global term, every token of a rollout shares the same advantage adjustment. We plot the share of rollouts at each training step, for that run and for SRE-1’s run, with more than ten parallel calls in one turn (top) or repetition or incoherent text (bottom).
Figure 16: Dense credit assignment targets specific turns or tokens only. Over the run, the three kinds of mistake it targets became 12 to 343 times rarer. (a) Standard RL gives every turn the same advantage, and ours adjusts the mistaken turn or tokens. The third strip is a real rollout of 75 turns. (b) Flagged tokens per million at the start of training (open markers) and in its last 20 steps (filled markers).

We therefore assign credit densely (Figure 16a). When a turn or a span of tokens contains a mistake, we reduce the credit of that turn or span alone. Two systems inspired this: (a) Composer 2.5 [13], which inserts a hint at the point in a rollout where the model could have done better and distills the policy toward the hinted distribution for that turn only, and (b) MiMo-V2.6 [51], which masks or reshapes the advantages of flagged tokens such as malformed tool calls.

SRE-1 trained with credit reductions for turns that exceed the stated call limit, for repetition, and for malformed or wrong-language tokens. At the end of the run (step 200), 23.9% of rollouts received one of these reductions. Over the run, the three targeted mistakes became 12 to 343 times rarer (Figure 16b). Other settings changed over the same steps, so we do not attribute these reductions to credit assignment alone.

Harness

We design the training harness to match deployment. In this report, we train and evaluate the agent acting alone; like its base model, it can delegate parts of an investigation to sub-agents, but we do not study that here.

Tool-result cap. We limit how much of a tool result enters the context, and keep the rest of a long result in a file that the model can read or search with later bash tool calls. These limits are critical: raising the cap from 25k to 100k characters caused the model to frequently run out of context, and the mean score fell from 0.53 to 0.37 (Figure 17).

Figure 17: In this tool-result-cap ablation, a 100k-character cap reduces the score by 0.16. A larger cap lets a few tool results fill the context. At 100k, 181 of 512 rollouts exhausted it before answering. Each cap used the same 128 training incidents, an earlier model, and one judge.
Figure 18: Re-encoding a turn’s text can change its token ids, so we train on those the sampler produced. For one real model turn, the figure compares sampled ids (top) with ids re-encoded from the same characters (bottom), marking differing tokens. The two differ somewhere in 94% of rollouts.

Tokens in, tokens out (TITO). Most sampling frameworks (e.g. vLLM, SGLang) de-tokenize their output, returning text instead of the raw tokens. In RL, re-tokenizing that text before sending it back to the sampler would subtly change ~94% of rollouts (Figure 18). Our framework guarantees that we operate only with append-only token id streams. Figure 18 illustrates an example of how one string can tokenize in multiple different ways.

Harness randomization. Each time we train on an incident, we sample a new harness configuration for that rollout group, so that the policy cannot overfit to any one harness (Figure 19). Half of all groups run the evaluation setting unchanged. The other half randomize about 70 attributes, covering the tool interface, the budgets and whether they are stated, the form of the prompt, and the names and schemas of the tools, which allows more than 1050 combinations. Rollouts in a group share one configuration; varying it across groups helps avoid behavioral collapse, as with parallel calls. Inkling [46] and Scout [14] also vary tools or budgets during training; domain randomization supports transfer from simulation [47], and prompt formatting affects accuracy [42].

Figure 19: To prevent overfitting to one harness, we randomize about 70 prompt, tool, and budget attributes in half of all training groups. We show 13 attributes for six of the 29 groups run on one incident; tool names are stand-ins. The first column uses the evaluation setting, which matches the deployment harness. For the other five, teal marks values differing from the evaluation setting; the last row counts these differences. No two randomized groups for an incident had identical settings.
Figure 20: In this budget ablation, RL raises the judge’s score across the sampled turn and context budgets. The three blocks show mean scores for the base model and SRE-1, and their difference. Averaged over context, SRE-1 gains 0.12 with 30 to 90 turns and 0.08 with 100 to 160; averaged over turns, gains are 0.10 at both context budgets, all significant.

Budgets. Frontier models expose one effort level, such as “low”, “medium”, or “xhigh”. SRE-1 instead takes two budgets, one for turns and one for context, which gives finer control over latency. Randomized groups draw the two independently, so that one policy learns to work under any budget. Each tool result includes the remaining context budget, allowing the policy to condition its subsequent actions on available capacity. The harness asks for the answer before the context runs out, so 99.9% of the rollouts we trained on end with one. RL raised the judge’s score at every budget that we draw (Figure 20), and at deployment the two budgets move SRE-1 along the frontier of Figure 1 without retraining.

Parallel calls. All calls in a turn run concurrently, so calling tools in parallel shortens an investigation. However, RL alone did not preserve parallel calling. In four earlier training jobs the policy collapsed to one call per turn; in the first attempt at this run, calls per turn fell from 1.52 to 1.02 within 40 steps. Once every rollout makes one call per turn, RL cannot bring the behavior back because there is no variation left to reinforce. We therefore forked the run from before the collapse, telling the model in the prompt that tool calls made in the same turn run concurrently and adding a temporary penalty on turns that made too few parallel calls. Each randomized group draws one of four wordings of that statement, from neutral to emphatic. Calls per turn reached 2.4 by step 60, with no significant change in the validation score through step 40 (Figure 21).

Figure 21: Parallel-call ablation: without a hint and a temporary penalty, calls per turn fall to one. (a) Tool calls per turn with a hint and a temporary penalty, and without them. (b) Tool calls per investigation. (c) Validation score of both runs. The run with the hint changed other settings too.

Training dynamics

Curriculum. For RL, the learning signal depends on the reward variance within each group of 32 rollouts, so any group with either all-solved or no-solved problems has little gradient to learn from. ScaleRL [23] permanently removes a prompt once its pass rate is high, since a prompt that has become easy tends to stay easy. Unlike permanent filtering, our curriculum resamples both easy and hard prompts to detect performance regressions and reconsider previously unsolved prompts as training progresses (Figure 22). When all 32 rollouts pass, the prompt moves to an easy pool, and when none passes, to a hard pool. Prompts return at random, with a half-life of about 245 steps for easy prompts and about 25 for hard ones in live-tool investigation. The next group determines the pool again. Most returning prompts repeat their earlier outcome: 56% of returning easy prompts were again solved by every rollout, against 14% of ordinary draws, and 65% of returning hard prompts were again solved by none, against 19%. Because solved prompts leave the sample, the sampled training pass rate stays flat while the policy improves (Figure 23).

Figure 22: The curriculum temporarily removes prompts that every rollout solves or that none solves, returning them at random. (a) A prompt moves to the easy pool when all 32 rollouts pass and to the hard pool when none does. (b) Share of prompts seen so far in each pool at each step. The dataset changes at step 126, where the shaded region begins.
Figure 23: The sampled training pass rate stays flat because the curriculum sets aside prompts that the policy fully solves. (a) Share of prompts seen so far in each pool over steps 12 to 24 (early) and 101 to 125 (later). (b) Pass rate of the sampled groups, of all prompts (estimated by weighting each pool’s pass rate by its share), and of the validation set. Until the dataset changes at step 126, the policy keeps improving on all prompts and on the validation set while the sampled rate stays flat. The larger dataset adds harder prompts, which lowers both training rates.

Variance filtering. A group contributes to the gradient only through its reward variance, and PODS [53] shows that training on the highest-variance subset of a larger sample learns faster in wall-clock time than training on all of it. We oversample by generating roughly twice as many prompts as the batch size. We then drop groups with low reward variance or no high-scoring rollout, and train on the top 64, ranked by age-discounted reward variance within each environment. On average, we trained on 53% of generated rollouts.

Validation. We run the validation set (Section 3) in the training harness at every 5th checkpoint with 8 rollouts each, as an asynchronous job on separately scheduled GPUs. The validation score rises from 0.45 for the base model to 0.60 at SRE-1’s checkpoint, an increase of 0.149 [0.125, 0.173] (Figure 24a). SRE-1 outscores the base model on 95 of the 101 incidents. Most of the gain came in the first 20 steps. A longer context window helps at almost every checkpoint: at 1M SRE-1 scores 0.66, an increase of 0.064 over 262k [0.042, 0.087].

Figure 24: RL raises the validation score at every context window, and a longer window raises it further at almost every checkpoint. We evaluate every 5th checkpoint on 101 incidents with 8 rollouts each. (a) Mean score, where the bracket is the gain from the base model to SRE-1 at 262k and the dashed line is the base model. (b) Estimated time per investigation, relative to the base model at 262k: the gain in (a) comes with longer investigations. The bands are the 1M window’s 95% interval.
Figure 25: Behavior changed after the score stabilized. Calls per turn rose to 4.1, then fell to 2.5. The rise follows the terms encouraging parallel calls, added at step 12. Offline synthesis, at 5.3 calls per turn, partly accounts for the peak. The plot covers all trained rollouts.

Speed vs accuracy. We add terms to the reward to control speed, and found that speed and accuracy usually move in opposite directions, so finding the optimal balance is difficult. As the policy learned to make more tool calls and to reason longer between them, investigations grew longer: SRE-1 takes an estimated 1.7 times the base model’s time at 262k and 5.0 times at 1M (Figure 24b). Over steps 135 to 155 the reverse happened (shaded in Figure 24): at 1M, the model took 39% fewer turns [30, 47] and wrote 43% fewer tokens per turn [38, 47], mostly reasoning, and its score fell by 0.021 [0.002, 0.041]. Calls per turn rose after we added terms encouraging parallel calls and then partly fell back (Figure 25).

Checkpoint selection. We chose step 110 of the 200 as SRE-1, balancing the validation score against speed. To keep our final evaluation a true held-out estimate, we did not measure the test set (Figure 1, Section 6.1) when choosing the checkpoint.

Generalization. With RL, the model solved incidents it could not solve before (Figure 26): SRE-1 solves 47.5% of the validation incidents in at least 1/8 rollouts, against 20.8% for the base model (+26.7 points [18.8, 35.6]). This demonstrates our model is generalizing to new scenarios.

Figure 26: RL increased the fraction of validation incidents solved at least once across 8 rollouts. (a) An illustration of solved at least once: example groups with 0/8 and 3/8 rollouts passing. (b) The share of the 101 validation incidents solved at least once in 8 rollouts, and the share of rollouts that pass, at every 5th checkpoint.

Infrastructure

The run used up to 512 GPUs across two clouds for 7.4 days. It ran up to 8,736 rollouts concurrently and ran 812,695 rollouts to completion, in which the model made 51.5 million tool calls. It trained on 409,600 of those rollouts, 76.2 billion tokens in all (Table 7).

Training system

Figure 27: Training spans two clouds that exchange only tokens and training batches. The platform hosts the trainer and samplers behind low-level APIs, so our orchestration and advantage logic run with the environments, tools, and judges. Each square is 32 GPUs. Judges graded 409,032 of the 409,600 trained rollouts; the other 568 submitted no answer.

Training runs on Cortex Training from Snowflake, which abstracts the trainer and the samplers behind low-level APIs (Figure 27). Our training code is a heavily modified fork of the open-source prime-rl and verifiers [7, 37]. The low-level work (forward passes, backward passes, and sampling) runs on Cortex, with 192 GPUs for the trainer and up to 320 for the samplers. The orchestration and the advantage logic run on a separate cloud, next to every environment, tool, and judge. There, an orchestrator drives every rollout: it sends prompts to the samplers, executes tool calls in the environments, and assembles batches for the trainer. We monitor training live in a web UI that we built for this work (Appendix E).

Figure 28: Sampling and training overlap, with rollouts continuing across weight updates and later turns sampled with newer weights. (a) A schematic of rollouts crossing weight updates. We bound their staleness at 2 steps. (b) A screenshot from our web UI across three weight updates.

We overlap sampling and training to avoid idle compute caused by differences in their execution times (Figure 28). Following PipelineRL [36], we use asynchronous training, allowing sampling to continue during gradient updates and updating the samplers’ weights mid-rollout. In this run the trainer spent 95% of a median 47-minute step in its forward and backward passes and waited a median of 80 seconds for its next batch. We set max staleness to 2 steps, because the trainer–sampler mismatch grows with staleness: in a small reproduction, tokens sampled with weights 2 steps old had 3.0 times the mismatch of tokens sampled with current weights.

Trainer numerics are critical

Figure 29: After a precision fix in gradient accumulation, a fresh run of the same recipe scored 0.026 higher [0.012, 0.040]; other minor fixes accompanied it. (a) Additions retained during accumulation: bf16 and fp32 in a probe, and bf16 on a recorded training step. (b) Validation score before and after the fix. (c) Trainer–sampler mismatch per step in SRE-1’s run and in an earlier production run, with each run’s median dashed.

Numerical precision was a significant source of training instability. We run the forward and backward passes in bf16 for speed, and keep gradient accumulation, the LM head, the master weights, and the optimizer state in fp32, a variant of standard mixed-precision training [28]. We identified a bug in which gradients were accumulated in bf16 rather than fp32, causing small contributions to be lost through rounding. In a controlled probe, a bf16 accumulator lost all 31 small terms that an fp32 accumulator kept (Figure 29a), and on one recorded training step an estimated 12.6% of the additions were lost. After the fix, a fresh run of the same recipe scored 0.026 higher on validation incidents at step 25 [0.012, 0.040], a 24% larger gain over the base model (Figure 29b). The same release included other, minor fixes, so we cannot isolate this precisely. We tested about twenty reward and advantage changes that month, and none had this large of an impact.

Numerical consistency is particularly important for our objective, which weights token gradients using trainer-to-sampler importance ratios, so any disagreement between the two becomes error in the gradient (Figure 29c shows this mismatch over the run). We addressed other such problems, for example master weights stored in bf16, which rounded away most updates at our learning rate.

Restarts and recipe changes

The run restarted 14 times, for recipe changes, preemption, and platform reclaims, and changed its recipe at 11 of them (Figure 30). On a graceful stop, we save each rollout in flight at a turn boundary and the next job continues it, because regenerating interrupted rollouts would bias training toward short ones [15] (Appendix E). We change the recipe by resuming the same run with a new configuration rather than starting a new one. Most changes adjusted how strongly the reward valued speed and cost. Others changed the dataset and added harness variations. Other long RL runs are also resumed after failures: MAI-Thinking-1 [29] recovers from collapsed runs by self-distillation, reporting that a checkpoint from before a numerical collapse often already carries the instability. The collapse of parallel calling (Section 4.4) was behavioral, and forking from an earlier checkpoint recovered it.

Figure 30: The whole run on one time axis: the validation score rose from 0.45 to 0.61 over 200 steps, through 11 recipe changes and 14 restarts. The rows show recipe changes, rollouts in flight, training steps, the validation score, the environments’ error rate and latency, judge scoring, and the coding agents operating the job. The shades of teal cycle from one policy version to the next to tell consecutive steps apart. The gray bands are gaps around restarts. Press “play” on the right; hover to zoom.

Results

We evaluate on a test set of 49 challenging live production cases run in our production harness, the synthesis validation set of 73 problems, and the 101 validation incidents in the training harness used for checkpoint selection and the training curves (Section 4.5).

Scoring. Each chain is scored from 0 to 1 against a reference chain, averaging the scores of frontier-model judges [55] from three model families [48] to offset a judge’s tendency to favor its own outputs [34]. We ask each how similar the submitted chain is to the reference, and we tuned the judging prompt to match the scores of on-call engineers on 87 labeled chains (mean squared error 0.024). We count a score of 0.8 or more as a pass, the threshold at which on-call engineers judged a chain “correct” during calibration. A passing chain names the same trigger, mechanism, and root cause as the reference, though it may miss one or two minor details or supporting pieces of evidence. We report this three-judge average for all three evaluation sets. The training reward instead uses one randomly drawn judge per group, to mitigate reward hacking.

Challenging live production cases

Figure 31: Most candidates were lost to expiring telemetry, not to the audit of the rollouts. Teal bars count the alerts left at each stage and orange bars the removals; the lower panel bins the 49 cases by the mean score of the two models that screened them.

Setup. We draw the test set from recent production incidents, investigated using live integrations. We began with 175 live production alerts with reference chains from our multi-agent system (Section 3.2). After excluding alerts whose telemetry would expire within days of evaluation or that could no longer be accessed, 67 remained; a frontier model and an earlier SRE-1 checkpoint each investigated them twice. Auditing these rollouts removed 12 alerts where a rollout read post-alert records or two rollouts lacked evidence to answer, then 4 without a scored checkpoint rollout and 2 solved by neither model, leaving 49 (Figure 31). The pool over-represented alerts our production system had scored lower on. We run each case five times in our production harness, which uses the training harness’s prompt, answer format, and context management on live integrations, and score rollouts. Unless stated otherwise, runs use a 150-turn cap and a 1M-token context. Figure 1 and Table 8 show the results for our configurations and each other model at its strongest setting, and Table 9 lists every configuration. We compare against 25 other configurations, including four frontier models at every tested effort level [3, 5, 32, 33], four other models [2, 4, 16, 31], the base model, and ensembles.

A single investigation. RL raises the pass rate of a single investigation from 6.9% for the base model to 38.8% for SRE-1, an increase of 31.8 points [22.4, 41.6] (Table 8). SRE-1 solves 32 of the 49 cases at least once, against 6 for the base model. One SRE-1 investigation passes as often as Fable 5.2 at medium effort, for under a fifth of its cost, and more often than Opus 5.5 at high effort at 33% of its cost. Only Opus 5.5 at xhigh effort and Fable 5.2 at high and xhigh effort pass significantly more often, at 5, 9, and 12 times the cost.

Context window. The pass rate rises with the context window, from 15.5% at 262k, where we also cap an investigation at 60 turns, to 38.8% at 1M (the points along our line in Figure 1).

Ensembles. The synthesis skill of Section 3.4 also combines several investigations into one answer. When SRE-1 combines its own investigations of a test case, its pass rate climbs from 38.8% for one investigation to 71% for an ensemble of five (Figure 32). The ensemble of five is a tree: two investigations and three investigations are each synthesized, and the two syntheses are combined into the final answer (Figure 12). An ensemble of three passes 60%, against 47.8% for the costlier Opus 5.5 at xhigh effort. The ensemble of five passes more often than any Opus 5.5 (xhigh) configuration we measured, including Opus’s own ensemble of five, which passes 65% at 4.5 times the cost of ours. Synthesis can recover correct causal hypotheses from individual investigations, improving ensemble performance when the constituent investigations produce different conclusions.

Pareto frontier. As shown earlier in Figure 1, SRE-1 has the highest accuracy at every price point from its cheapest configuration upward, because (a) we have fine-grained control over its context window, and (b) ensembling allows us to spend extra budget to gain additional accuracy.

Figure 32: An ensemble of five SRE-1 investigations passes 71% of the time, against 65% for an ensemble of five from Opus 5.5 (xhigh), which costs 4.5 times as much. We plot the pass rate on the 49 test cases against the cost per answer, synthesis included, relative to one SRE-1 investigation, for ensembles of 1, 2, 3, and 5. The bars are 95% intervals. On mean score, the two ensembles of five tie at 0.83. Hover over a point for its mean score.

Offline synthesis

Setup. We measure offline synthesis on the synthesis validation set of 73 problems, 40 of them from environments held out of training. Our checkpoints run in the training harness with 8 rollouts per problem. The frontier models run through their APIs: Opus 5.5 with 8 rollouts per problem, and Fable 5.2 with 2, to reduce API cost. The same three judges score every rollout.

ModelMean scorePass rateSRE-1’s lead in pass rate
SRE-10.749 [0.708, 0.786]51.7%
Opus 5.5 (xhigh)0.743 [0.704, 0.778]44.5%+7.2 points [1.5, 12.8]
Fable 5.2 (xhigh)0.731 [0.692, 0.764]39.0%+12.7 points [5.3, 20.5]
Base model0.650 [0.613, 0.684]23.5%
Table 3: Offline synthesis on the synthesis validation set of 73 problems, with 95% intervals over problems. The last column is the paired difference in pass rate, SRE-1 minus the model.
Figure 33: On offline synthesis, SRE-1 passes more often than Opus 5.5 and Fable 5.2. We evaluate on the synthesis validation set of 73 problems. (a) Pass rate, with SRE-1’s paired gains over Opus 5.5 (xhigh) and Fable 5.2 (xhigh). (b) Mean score. (c) The run’s pass rate at every 5th step, with both frontier levels dashed.

On offline synthesis, SRE-1 passes 7.2 points more often than Opus 5.5 (xhigh) [1.5, 12.8] and 12.7 points more often than Fable 5.2 (xhigh) [5.3, 20.5] (Table 3, Figure 33). Its mean score does not differ significantly from Opus 5.5’s (+0.006 [−0.008, 0.019]). RL raises the mean score by 0.099 [0.075, 0.123] and the base model’s pass rate from 23.5% to 51.7% (+28.3 points [21.6, 34.9]). The gain is smaller but still significant on the 40 problems from environments never seen in training (+0.07 [0.04, 0.10]).

Limitations

Conclusion

We trained SRE-1 with RL to investigate production incidents, and on challenging live production cases its configurations dominate the Pareto frontier of pass rate against cost. Each configuration passes more often or costs less than every one of the 25 alternatives we measured. On validation incidents, RL raises the mean score from 0.45 to 0.60 [0.56, 0.64], with a higher score on 95 of 101 incidents. An SRE-1 investigation costs a small fraction of the strongest frontier models’, allowing several investigations per alert. An ensemble of five ties the strongest frontier model at lower cost. We obtained this result through months of work on realistic captured and synthetic environments, evaluations, a new reference-chain pipeline, scaling reinforcement learning infrastructure, and ablations.

Future work. We are scaling up to larger models, adding new tasks, and improving the realism and diversity of our environments.

Contributors

Ordered alphabetically within each group.

Primary contributors
  • Michael Alverson
  • Kshitij Alwadhi
  • Sean Bell (Lead Researcher)
  • Charlie Ji
  • Xuchao Jia
  • Dhruv Mahajan (Lead Researcher)
  • Henry Maier
  • Harsha Polavaram
  • Abhishek Sharma
  • Harry Shin
  • Alvin Zhu
Other contributors
  • Vasanth Balakrishnan
  • Madhu CS
  • Deep Desai
  • Michael Preibisch
  • Vishwa Sheth

Acknowledgements

SRE-1 was trained on Cortex Training from Snowflake. We were an early design partner for the platform, and we thank the Snowflake team for collaborating closely with us to support this work. We also thank Annalise Krueger and Claire Yin, and the rest of the ResolveAI team for annotations, evaluations, and building the platform. Finally, we thank Spiros Xanthos (CEO), Mayank Agarwal (CTO), and Steven Karis (Chief Architect) for funding and supporting this work.

References

  1. Toufique Ahmed, Supriyo Ghosh, Chetan Bansal, Thomas Zimmermann, Xuchao Zhang, and Saravan Rajmohan. Recommending root-cause and mitigation steps for cloud incidents using large language models. In ICSE, 2023. arXiv:2301.03797.
  2. Anthropic. Introducing Claude Fable 5.1 and Claude Mythos 5.1. Blog post, www.anthropic.com/claude-fable-and-mythos-5-1, 2026.
  3. Anthropic. Introducing Claude Fable 5.2 and Claude Mythos 5.2. Blog post, www.anthropic.com/claude-fable-and-mythos-5-2, 2026.
  4. Anthropic. Introducing Claude Haiku 5.5. Blog post, www.anthropic.com/claude-haiku-5-5, 2026.
  5. Anthropic. Introducing Claude Opus 5.5. Blog post, www.anthropic.com/claude-opus-5-5, 2026.
  6. Betsy Beyer, Chris Jones, Jennifer Petoff, and Niall Richard Murphy, editors. Site Reliability Engineering: How Google Runs Production Systems. O’Reilly Media, 2016.
  7. William Brown. verifiers: Environments for LLM reinforcement learning. Software, github.com/PrimeIntellect-ai/verifiers, 2025.
  8. Shiyi Cao, Dacheng Li, Fangzhou Zhao, Shuo Yuan, Sumanth R. Hegde, Connor Chen, Charlie Ruan, Tyler Griggs, Shu Liu, Eric Tang, et al. SkyRL-Agent: Efficient RL training for multi-turn LLM agent. arXiv preprint arXiv:2511.16108, 2025.
  9. Yinfang Chen, Manish Shetty, Gagan Somashekar, Minghua Ma, Yogesh Simmhan, Jonathan Mace, Chetan Bansal, Rujia Wang, and Saravan Rajmohan. AIOpsLab: A holistic framework to evaluate AI agents for enabling autonomous clouds. In MLSys, 2025. arXiv:2501.06706.
  10. Yinfang Chen, Huaibing Xie, Minghua Ma, Yu Kang, Xin Gao, Liu Shi, Yunjie Cao, Xuedong Gao, Hao Fan, Ming Wen, et al. Automatic root cause analysis via large language models for cloud incidents. In EuroSys, 2024. arXiv:2305.15778.
  11. Jackson Clark, Yiming Su, Saad Mohammad Rafid Pial, Yifang Tian, Lily Gniedziejko, Hans-Arno Jacobsen, Yinfang Chen, and Tianyin Xu. SREGym: A live benchmark for AI SRE agents with high-fidelity failure scenarios. In NeurIPS Evaluations and Datasets Track, 2026. arXiv:2605.07161.
  12. Cursor Research. Composer 2 technical report. arXiv preprint arXiv:2603.24477, 2026.
  13. Cursor Team. Introducing Composer 2.5. Blog post, cursor.com/blog/composer-2-5, 2026.
  14. Datadog AI Research. Scout 1.0: Post-training a model for SRE investigations. Technical report, PDF; announced at datadoghq.com/blog/ai/introducing-scout-sre-specialized-model-bits-ai, 2026.
  15. DeepSeek-AI. DeepSeek-V4: Towards highly efficient million-token context intelligence. arXiv preprint arXiv:2606.19348, 2026.
  16. DeepSeek-AI. DeepSeek-V4.1-Flash: Pushing the limits of KV cache compression. arXiv preprint arXiv:2609.19969, 2026.
  17. Wei Fu, Jiaxuan Gao, Xujie Shen, Chen Zhu, Zhiyu Mei, Chuyi He, Shusheng Xu, Guo Wei, Jun Mei, Jiashu Wang, et al. AReaL: A large-scale asynchronous reinforcement learning system for language reasoning. In NeurIPS, 2025. arXiv:2505.24298.
  18. Chang Gao, Chujie Zheng, Xiong-Hui Chen, Kai Dang, Shixuan Liu, Bowen Yu, An Yang, Shuai Bai, Jingren Zhou, and Junyang Lin. Soft adaptive policy optimization. arXiv preprint arXiv:2511.20347, 2025.
  19. Leo Gao, John Schulman, and Jacob Hilton. Scaling laws for reward model overoptimization. In ICML, 2023. arXiv:2210.10760.
  20. Supriyo Ghosh, Manish Shetty, Chetan Bansal, and Suman Nath. How to fight production incidents? An empirical study on a large-scale cloud service. In SoCC, 2022. doi:10.1145/3542929.3563482.
  21. Albert Gong, Kyuseong Choi, Abhineet Agarwal, Jason Schechner, Ryan Huang, Raj Agrawal, Anish Agarwal, and Raaz Dwivedi. ORCA-bench: How ready are language model agents for oncall? arXiv preprint arXiv:2607.28545, 2026.
  22. Saurabh Jha, Rohan R. Arora, Yuji Watanabe, Takumi Yanagawa, Yinfang Chen, Jackson Clark, Bhavya Bhavya, Mudit Verma, Harshit Kumar, Hirokuni Kitahara, et al. ITBench: Evaluating AI agents across diverse real-world IT automation tasks. In ICML, 2025. arXiv:2502.05352.
  23. Devvrit Khatri, Lovish Madaan, Rishabh Tiwari, Rachit Bansal, Sai Surya Duvvuri, Manzil Zaheer, Inderjit S. Dhillon, David Brandfonbrener, and Rishabh Agarwal. The art of scaling reinforcement learning compute for LLMs. In ICLR, 2026. arXiv:2510.13786.
  24. Ling Team, Anqi Shen, Baihui Li, Bin Hu, Bin Jing, Cai Chen, Chao Huang, Chao Zhang, Chaokun Yang, Cheng Lin, et al. Every step evolves: Scaling reinforcement learning for trillion-scale thinking model. arXiv preprint arXiv:2510.18855, 2025.
  25. Zichen Liu, Changyu Chen, Wenjun Li, Penghui Qi, Tianyu Pang, Chao Du, Wee Sun Lee, and Min Lin. Understanding R1-Zero-like training: A critical perspective. In COLM, 2025. arXiv:2503.20783.
  26. Michael Luo, Naman Jain, Jaskirat Singh, Sijun Tan, Ameen Patel, Qingyang Wu, Alpay Ariyak, Colin Cai, Tarun Venkat, Shang Zhu, et al. DeepSWE: Training a fully open-sourced, state-of-the-art coding agent by scaling RL. Blog post, Agentica and Together AI, together.ai/blog/deepswe, 2025.
  27. Peter Menzies and Helen Beebee. Counterfactual theories of causation. In The Stanford Encyclopedia of Philosophy, revised 2024. plato.stanford.edu/entries/causation-counterfactual.
  28. Paulius Micikevicius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich Elsen, David Garcia, Boris Ginsburg, Michael Houston, Oleksii Kuchaiev, Ganesh Venkatesh, et al. Mixed precision training. In ICLR, 2018. arXiv:1710.03740.
  29. The Microsoft AI Team. MAI-Thinking-1: Building a hill-climbing machine. Technical report, Microsoft AI, microsoft.ai/pdf/mai-thinking-1.pdf, 2026.
  30. MiniMax. MiniMax-M1: Scaling test-time compute efficiently with lightning attention. arXiv preprint arXiv:2506.13585, 2025.
  31. OpenAI. GPT-5.6 Luna. Model documentation, developers.openai.com/api/docs/models/gpt-5.6-luna, 2026.
  32. OpenAI. GPT-6 Astra. Model documentation, developers.openai.com/api/docs/models/gpt-6-astra, 2026.
  33. OpenAI. GPT-6.1 Sol. Model documentation, developers.openai.com/api/docs/models/gpt-6.1-sol, 2026.
  34. Arjun Panickssery, Samuel R. Bowman, and Shi Feng. LLM evaluators recognize and favor their own generations. In NeurIPS, 2024. arXiv:2404.13076.
  35. Bowen Peng, Jeffrey Quesnelle, Honglu Fan, and Enrico Shippole. YaRN: Efficient context window extension of large language models. In ICLR, 2024. arXiv:2309.00071.
  36. Alexandre Piché, Ehsan Kamalloo, Rafael Pardinas, Xiaoyin Chen, and Dzmitry Bahdanau. PipelineRL: Faster on-policy reinforcement learning for long sequence generation. TMLR, 2026. arXiv:2509.19128.
  37. Prime Intellect. prime-rl. Software, github.com/PrimeIntellect-ai/prime-rl, 2025.
  38. Prometheus Authors. Alerting (best practices). Documentation, prometheus.io/docs/practices/alerting, accessed November 2026.
  39. Qwen Team. Qwen3.8-27B. Model card, huggingface.co/Qwen/Qwen3.8-27B, 2026.
  40. John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
  41. John Schulman. Approximating KL divergence. Blog post, joschu.net/blog/kl-approx.html, 2020.
  42. Melanie Sclar, Yejin Choi, Yulia Tsvetkov, and Alane Suhr. Quantifying language models’ sensitivity to spurious features in prompt design or: How I learned to start worrying about prompt formatting. In ICLR, 2024. arXiv:2310.11324.
  43. Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. DeepSeekMath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024.
  44. Shopify. Shopify merchants generate record-breaking $14.6 billion in Black Friday Cyber Monday sales. News post, Shopify, shopify.com/news/bfcm-data-2025, 2025.
  45. Splunk and Oxford Economics. The hidden costs of downtime. Report, Splunk; announced in newsroom.cisco.com, 2026.
  46. Thinking Machines Lab. Inkling: Our open-weights model. Blog post, thinkingmachines.ai/news/introducing-inkling, 2026.
  47. Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In IROS, 2017. arXiv:1703.06907.
  48. Pat Verga, Sebastian Hofstätter, Sophia Althammer, Yixuan Su, Aleksandra Piktus, Arkady Arkhangorodsky, Minjie Xu, Naomi White, and Patrick Lewis. Replacing judges with juries: Evaluating LLM generations with a panel of diverse models. arXiv preprint arXiv:2404.18796, 2024.
  49. Junlin Wang, Jue Wang, Ben Athiwaratkun, Ce Zhang, and James Zou. Mixture-of-Agents enhances large language model capabilities. In ICLR, 2025. arXiv:2406.04692.
  50. Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In ICLR, 2023. arXiv:2203.11171.
  51. Xiaomi LLM-Core Team. MiMo-V2.6: Scaling reinforcement learning towards self-improvement. arXiv preprint arXiv:2610.11959, 2026.
  52. Junjielong Xu, Qinan Zhang, Zhiqing Zhong, Shilin He, Chaoyun Zhang, Qingwei Lin, Dan Pei, Pinjia He, Dongmei Zhang, and Qi Zhang. OpenRCA: Can large language models locate the root cause of software failures? In ICLR, 2025. openreview.net/forum?id=M4qNIzQYpd.
  53. Yixuan Even Xu, Yash Savani, Fei Fang, and J. Zico Kolter. Not all rollouts are useful: Down-sampling rollouts in LLM reinforcement learning. TMLR, 2026. arXiv:2504.13818.
  54. Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Weinan Dai, Tiantian Fan, Gaohong Liu, Juncai Liu, et al. DAPO: An open-source LLM reinforcement learning system at scale. In NeurIPS, 2025. arXiv:2503.14476.
  55. Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric P. Xing, et al. Judging LLM-as-a-judge with MT-Bench and Chatbot Arena. In NeurIPS Datasets and Benchmarks Track, 2023. arXiv:2306.05685.

Appendix

A. Additional environment details

Incident sources

SourceOriginShare of 1,503-incident datasetShare of 904-incident datasetServed fromReference chainBase model never solvesStrongest agent solves
Live incidentsInternal23%31%Live read-only backends and restored snapshotsMulti-agent system91%69%
Incident replaysInternal34%17%Preserved telemetryMulti-agent system88%75%
Synthetic environmentsSynthetic35%44%Restored snapshotsBy construction67%85%
Licensed environmentsVendor8%8%Restored snapshotsBy construction64%82%
Table 4: Live-tool incident sources. Shares are of the 1,503-incident dataset (1,273 for training; 230 held out, 101 of them the validation set) and of the earlier 904-incident dataset. Base model: share of incidents never solved in four rollouts, in an earlier version of the dataset. Strongest agent: our production system, a team of frontier-model agents, and the share of incidents it solved at least once; replay incidents with no record are left out.

Quality checks

CheckAn incident is dropped whenExcluded
Reference-chain qualityA link restates a symptom or a mitigation instead of following from cited evidence, or pre-alert telemetry does not support the chain28
SolvabilityNo evidence path reaches the reference chain: the strongest agent never solves it, its best rollout scores below 0.6, and a blind tracer fails4
Human reviewAn issue was flagged48
LeakageCode history, tickets, chat, documents, metric names, or recorded rollouts give away the answer in a way a real investigation would not see63
DeduplicationIt is similar to another alert and root cause9
DecontaminationIt shares an incident, or a template whose answer carries over, with a held-out evaluation set4
Too easyStrong model and the RL base model both have high pass rate4
Table 5: Quality checks applied to every incident of the dataset before training, with the number each excluded among 1,663 candidates.

Environment serving

Snapshots. For internal incidents (i.e., Resolve investigating Resolve), we copy raw storage blocks for logs, metrics, and traces into object storage, together with dashboards, the service graph, alert history, and code. We restore the blocks into open-source query engines on the training cluster, allowing real queries against frozen data. We serve synthetic incidents entirely from snapshots, live incidents partly through read-only live backends, and incident replays from preserved telemetry.

Fidelity. To measure how faithful these environments are, we rerun the tool calls that each reference investigation used to reach its answer and compare the results with what production returned. On average, 81% of a live incident’s calls return the same result. Most of the other 19% are calls the environment cannot serve at all, because it does not offer that tool or the query exceeds a backend’s scan limit. Of the calls it can serve, 94.5% return the same result as production.

Requests. Every remote tool call in training goes through one service, the dispatcher, which handled 29.9 million backend calls over the run; about 1.1% of them failed the way production calls do. It pins every call to the alert time.

Responses. It rolls alerts and tickets back to their state at alert time, withholds reports edited afterwards, and strips resolution fields so an open ticket reads as an ordinary in-progress record.

Environment types

Figure 34: Each environment type exercises the tools differently: code reads are 53% of calls in live environments against 30% to 32% elsewhere, and alerts, tickets, and events are 9% of calls in replays against 1% to 2%. We plot the share of the 45.3 million answered calls in each tool family, by environment type.

Tool use differs by environment type (Figure 34). Call shares are significantly larger than elsewhere for code reads in live environments, metrics in snapshots, and alerts, tickets, and events in replays. Logs account for similar shares in all three.

Production noise

We retain production tool failures during training so the policy learns to handle them, and we inject no additional failures. Backend calls failed in 1.1% of attempts, affecting 18.1% of training investigations (Figure 35). A failed call never caused an investigation to be dropped from its batch.

Figure 35: SRE-1 trains with real tool failures in 6% to 36% of investigations at every step. We retain failures because the policy must handle them in production. (a) Share of investigations with a failed tool call. (b) Causes of the 337,345 failed backend calls. (c) Failure rate per backend call by environment type. None of the failures was simulated.

Failure rates showed no trend across the run. Most failures were unreachable systems or timeouts (Figure 35b). Backend calls in live environments failed in 3.5% of attempts, compared with 0.32% for replayed telemetry and 0.20% for restored snapshots served from our stores (Figure 35c). Investigations with a failed call produced an answer 99.8% of the time. We track failures by step and environment type to compare training with production.

B. Explore one training batch (interactive)

On the web page this figure is interactive: it opens one training batch of 2,048 rollouts for reading, down to single turns. This gives a visual sense of what our actual rollouts, calls, and advantages look like.

Figure 36: In this real training batch of 2,048 rollouts, the 32 rollouts per prompt vary widely in outcome and length. Group-relative advantages use this variation for learning. (a) A grid of 64 prompts by 32 rollouts, where teal marks a passing score and a tick marks an offline-synthesis problem. (b) The chosen prompt’s 32 rollouts along their context windows. (c) The chosen rollout, turn by turn.

C. Additional training details

D. Ablations

We ran extensive ablations throughout the project to validate our design decisions. In some cases we ran clean A/B tests, and in others we forked a training run and compared behavior before and after the fork point. We report all 33 here, including the 23 that were neutral, negative, or not adopted, because negative results are rarely published and we hope they save others the compute. The ablations took more than 221,000 GPU-hours of training, 2.5 times SRE-1’s own run, and 3.5 million judge calls. The whole recipe search behind this report took 60 training runs, more than 660,000 GPU-hours, and 11 million judge calls.

Table 6 numbers them in descending order of impact, and Figure 37 draws the curves behind the same numbers. Most compare one training run per arm for 10 to 20 steps, and several ran on an earlier model, so each supports the decision it tested and may not generalize. Harness and sampling settings moved the score most, by 0.12 to 0.16 at a fixed checkpoint, and two of them decide whether an investigation has room left to answer. In every A/B pair of training runs, the two runs’ validation scores after the same number of steps (usually 15) differed by less than 0.05; the largest gap, 0.049, was for the wide importance-ratio band (row 4 of Table 6). Two evaluations of the same weights differed by 0.008 [0.001, 0.015], so effects near 0.01 are within evaluation noise.

#AblationResult
Changes that helped
1Capping inline tool results at 25k characters (Figure 17)A 100k cap reduced the score by 0.16 [0.13, 0.20] and left a third of rollouts out of context*
2Reserving room for a full final turn and the answer+0.14 [0.12, 0.16]*
3Sampling at temperature 1 instead of 0.6+0.12 [0.10, 0.14]*
4A wide importance-ratio band instead of a narrow one (Figure 13)+0.049 after 15 steps [0.032, 0.066], in a pair that differed only in the band†
5fp32 gradient accumulation (Figure 29)+0.026 at step 25 [0.012, 0.040]‡
6Dense credit for tool mistakes+0.017 [0.006, 0.028]; mistakes fell to 0.44 of their starting rate [0.37, 0.53], against 0.84 [0.69, 1.04] without it; scaled by the fraction of the turn to keep parallel calls
7A newer dataset with more incidents (904 → 1,025)+0.012 [0.004, 0.019]
8One judge per group, from a set of 13 across providers (Figure 14)A three-judge average tracked a blind reference more closely than a single judge (correlation 0.95 against 0.92; +0.028 [0.006, 0.054])
9A continuous judge score instead of a binary passA binary pass gave 27%–36% of hard incidents a trainable group, against 57%–60% under the continuous score; an early binary run scored 0.024 higher at step 10 [0.009, 0.040], and its later rounds are incomplete
10A hint and a temporary penalty for parallel calls (Figure 21)Calls per turn recovered from 1.02 to 2.4 by step 60, with no significant change in the validation score through step 40
Neutral, negative, or not adopted
11A KL anchor to the sampler−0.039 [−0.055, −0.024]: it slowed learning
12PPO’s clip [40] instead of CISPOPPO scored 0.036 higher after 10 steps [0.013, 0.059], one run each; we kept CISPO, following ScaleRL*
13Starting from supervised fine-tuning, first studyStarted 0.08 higher and led by 0.034 after 15 steps [0.023, 0.045]
14A budget-relative penalty in the reward−0.027 [−0.036, −0.017]
15Withholding credit for citation mistakes−0.020 [−0.028, −0.011]: dense credit does not always help
16Supplying extra written knowledge about the environment−0.016 [−0.024, −0.008]
17Stacking four single changes−0.012 against its own baseline [−0.021, −0.004]: effects did not add
18Stronger speed incentives in the reward−0.012 [−0.021, −0.003]
19SAPO’s soft gate instead of CISPO [18]No significant difference after 10 steps (+0.022 [−0.005, 0.047])*
20An instruction-only nudgeNo significant difference (+0.012 [−0.008, 0.030])*
2164 rollouts per prompt instead of 32No significant difference (−0.009 [−0.027, 0.009])†
22Synchronous training instead of asynchronousNo significant difference (+0.006 [−0.020, 0.033]); we keep asynchronous training because synchronous stepping idles whichever side is faster*
23Starting from supervised fine-tuning, second studyStarted 0.09 higher; no significant lead after 15 steps (+0.006 [−0.012, 0.025])
24A higher minimum contextNo significant difference (+0.005 [−0.004, 0.014])
25A notice of the remaining budgetNo significant difference (+0.003 [−0.017, 0.022])*
26The newer dataset, on the next recipeNo significant difference (−0.002 [−0.010, 0.005])
27A cost on tool callsNo significant difference (+0.002 [−0.005, 0.010])
28Other precision changesNo significant difference (−0.001 [−0.011, 0.008])
29Prompt-balanced loss weightingNo significant difference (0.000 [−0.007, 0.008])
30A larger fixed budgetMore turns, no more incidents solved*
31A fork that reset the optimizer stateWeights moved less over the next 20 steps (one pair; score not compared)
32Telemetry simulated by a modelPicked the better of two models only 66% of the time against live runs [54%, 75%], so we removed it
33Reference chains written by experts instead of the multi-agent systemNo significant change in score (0.012 [−0.013, 0.034])
Table 6: Ablations and measurements behind our design decisions, numbered in descending order of impact within each block. Differences in validation score are after 15 steps unless stated, with 95% intervals paired over incidents; row 1 was scored on 128 training incidents. * An earlier model, on an earlier validation set. † An earlier validation set. ‡ Not a controlled pair: other, minor fixes shipped in the same release.
Figure 37: Among ablations with per-incident records, harness and sampling settings changed the score most, and no training change produced a difference of 0.05 or more at the marked step. Each cell compares runs with the change (teal) and without it (orange), by validation score unless the cell is labeled otherwise (cell 1 uses 128 training incidents), and gives their paired difference at the marked step with its 95% interval, in bold when it excludes zero. The summary column plots the score differences on one axis. Each arm is one training run. The numbers and marks are those of Table 6, and marked cells use separate scales. Rows 10 and 30 to 33 of the table have no per-incident records and are not drawn.

E. Infrastructure and operations

RunValue
Base modelQwen3.8-27B, dense, RL from the base weights
HardwareUp to 512 GPUs: 192 for the trainer, 320 for samplers (160 for the last three steps)
Duration7.4 days, restarts included; 86.6k GPU-hours; median step 47 min
Rollouts812,695 run to completion; 409,600 trained: 311,680 investigations, 97,920 syntheses
Tool use51.5 million tool calls by the model and 81B tokens of tool results read, over all completed rollouts
Tokens76.2B trained, 20.8B of them generated by the policy; 2.5T prompt tokens processed
Median rollout195k tokens of context, 26 turns, 63 tool calls
Table 7: The training run.

Fault tolerance

Figure 38: We resume saved rollouts after a restart, to preserve their generation and to avoid biasing training toward short rollouts. When the incident environment was unchanged, 10,715 of 10,723 (99.9%) rollouts continued from their saved state. The 3,050 rollouts regenerated from the start occurred at the three restarts that changed their environment.

Rollouts interrupted by a stop resume after the restart (Figure 38). In early runs, each restart discarded about 1,500 unfinished rollouts and an hour or more of generation. Therefore, on a graceful stop we save each rollout at a turn boundary, and the next job continues it if nothing it depends on changed. Where a restart left the environment unchanged, 99.9% of suspended rollouts continued. At the three restarts that changed the environment, we regenerated them instead of risking a mismatched continuation.

Agent-operated development

Figure 39: Between 70% and 95% of the agents that built and ran training were started by other agents. (a) The 16,182 coding agents in one lead researcher’s records over 19 weeks, by depth below the human operator. The lower figure assumes that the operator started every run whose launcher was not recorded. (b) Delegated agent work per day, which produced 7,363 written reports in all.

The training system was built and operated entirely by coding agents with human operators. Coding agents enabled a small team, with 11 primary contributors, to build and run the entire training system. Human operators direct Claude Code and Codex sessions, which start sub-agents, write the code, launch and resume the training job, and review each other’s work in writing. One lead researcher’s sessions account for 16,182 agents over 19 weeks (Figure 39). Model judges read the run as well: a “qualitative judge” (Appendix G) wrote 33,908 notes on sampled rollouts, and further model calls summarized those notes for each step and for the whole run.

Bespoke training dashboard

We built a web UI to monitor training as it runs. It records every rollout, turn, and token, places samplers, trainer, environments, and judges on a common time axis, and opens any element down to the token ids the sampler returned (Figure 40). We record at this granularity because several of the failures described above raised no error.

Figure 40: Several failures raised no error, so we built our own RL platform and web UI with instrumentation during training. The six screens show a comparison of runs, one run’s charts, the pipeline timeline, one group of 32 rollouts, one rollout, and one sampled token. The UI tracked 15,959 scalar series and 1.75 million timeline spans, and provides token-id access to all 409,600 trained rollouts. Some internal details redacted.

F. Additional results

ModelSettingMean scorePass rate (%)Cost (×)
SRE-1 ensembleensemble of 50.83[0.79, 0.87]71.4[57.1, 83.7]7.33[6.49, 8.20]
SRE-1 ensembleensemble of 30.80[0.76, 0.84]59.9[46.3, 72.8]3.76[3.30, 4.21]
SRE-1 ensembleensemble of 20.76[0.72, 0.80]50.2[37.6, 62.8]2.72[2.37, 3.07]
SRE-11M context0.70[0.66, 0.74]38.8[28.2, 49.8]1.00[0.87, 1.13]
SRE-1*1M context, guidance to work faster0.67[0.62, 0.72]36.2[25.2, 47.5]0.67[0.58, 0.76]
SRE-1524k context0.66[0.62, 0.71]33.1[22.0, 44.1]0.46[0.42, 0.51]
SRE-1393k context0.61[0.56, 0.66]24.1[15.5, 33.1]0.33[0.30, 0.35]
SRE-1262k context, 60-turn cap0.54[0.48, 0.60]15.5[8.2, 24.1]0.19[0.18, 0.20]
Fable 5.2*xhigh effort0.84[0.81, 0.87]71.0[60.4, 80.4]11.58[10.58, 12.61]
Opus 5.5 ensembleensemble of 50.83[0.78, 0.87]65.3[51.0, 77.5]33.25[30.20, 36.54]
Fable 5.1xhigh effort0.73[0.69, 0.78]48.2[38.0, 59.2]11.91[11.02, 12.88]
Opus 5.5xhigh effort0.74[0.70, 0.78]47.8[37.1, 58.8]5.00[4.47, 5.57]
Astra*xhigh effort0.70[0.64, 0.75]38.4[26.9, 49.8]8.77[7.64, 10.03]
Sol 6.1xhigh effort0.64[0.57, 0.69]29.8[19.6, 40.4]1.30[1.14, 1.47]
DeepSeek V4.1 Flash 1017xhigh effort0.50[0.45, 0.55]8.6[2.9, 15.5]0.23[0.20, 0.25]
Haiku 5.5xhigh effort0.44[0.39, 0.49]8.2[2.9, 14.3]0.60[0.55, 0.65]
Qwen3.8-27B1M context, xhigh effort0.44[0.39, 0.49]6.9[1.6, 13.9]0.38[0.35, 0.42]
Luna*xhigh effort0.41[0.35, 0.46]4.1[0.8, 9.0]0.15[0.13, 0.18]
Table 8: Test set: 49 challenging live production cases, five rollouts each, with 95% intervals over cases. Our configurations are listed first, then each other model at its strongest setting, each block in descending order of pass rate. Cost is relative to SRE-1 at a 1M context. * Missing a few rollouts.
ModelSettingMean scorePass rate (%)Cost (×)
SRE-1 ensembleensemble of 50.83[0.79, 0.87]71.4[57.1, 83.7]7.33[6.49, 8.20]
Fable 5.2*xhigh effort0.84[0.81, 0.87]71.0[60.4, 80.4]11.58[10.58, 12.61]
Opus 5.5 ensembleensemble of 50.83[0.78, 0.87]65.3[51.0, 77.5]33.25[30.20, 36.54]
Fable 5.2high effort0.81[0.78, 0.84]64.9[54.7, 74.7]8.83[8.05, 9.66]
Opus 5.5 ensembleensemble of 20.79[0.75, 0.84]61.2[46.9, 73.5]12.27[11.14, 13.48]
SRE-1 ensembleensemble of 30.80[0.76, 0.84]59.9[46.3, 72.8]3.76[3.30, 4.21]
Opus 5.5 ensembleensemble of 30.80[0.76, 0.85]59.2[44.9, 73.5]18.03[16.06, 20.11]
SRE-1 ensembleensemble of 20.76[0.72, 0.80]50.2[37.6, 62.8]2.72[2.37, 3.07]
Fable 5.1xhigh effort0.73[0.69, 0.78]48.2[38.0, 59.2]11.91[11.02, 12.88]
Opus 5.5xhigh effort0.74[0.70, 0.78]47.8[37.1, 58.8]5.00[4.47, 5.57]
SRE-11M context0.70[0.66, 0.74]38.8[28.2, 49.8]1.00[0.87, 1.13]
Astra*xhigh effort0.70[0.64, 0.75]38.4[26.9, 49.8]8.77[7.64, 10.03]
Fable 5.2*medium effort0.72[0.69, 0.76]38.3[28.1, 49.3]5.25[4.74, 5.81]
SRE-1*1M context, guidance to work faster0.67[0.62, 0.72]36.2[25.2, 47.5]0.67[0.58, 0.76]
SRE-1524k context0.66[0.62, 0.71]33.1[22.0, 44.1]0.46[0.42, 0.51]
Sol 6.1xhigh effort0.64[0.57, 0.69]29.8[19.6, 40.4]1.30[1.14, 1.47]
Fable 5.2low effort0.67[0.63, 0.71]29.4[20.4, 38.8]4.38[3.92, 4.90]
Astra*high effort0.66[0.60, 0.71]29.2[18.4, 40.2]7.76[6.80, 8.81]
Opus 5.5high effort0.65[0.60, 0.69]26.5[18.4, 35.5]3.06[2.70, 3.44]
Astra*medium effort0.61[0.55, 0.67]24.2[14.0, 34.7]5.83[5.15, 6.53]
SRE-1393k context0.61[0.56, 0.66]24.1[15.5, 33.1]0.33[0.30, 0.35]
Sol 6.1high effort0.63[0.56, 0.69]24.1[14.7, 34.3]1.19[1.05, 1.32]
Sol 6.1medium effort0.57[0.51, 0.63]18.4[9.4, 27.8]0.86[0.75, 0.98]
SRE-1262k context, 60-turn cap0.54[0.48, 0.60]15.5[8.2, 24.1]0.19[0.18, 0.20]
Opus 5.5medium effort0.59[0.54, 0.63]15.5[8.2, 24.1]2.41[2.16, 2.68]
DeepSeek V4.1 Flash 1017xhigh effort0.50[0.45, 0.55]8.6[2.9, 15.5]0.23[0.20, 0.25]
Haiku 5.5xhigh effort0.44[0.39, 0.49]8.2[2.9, 14.3]0.60[0.55, 0.65]
Astralow effort0.48[0.42, 0.53]7.8[2.5, 14.3]3.26[2.87, 3.66]
Sol 6.1low effort0.45[0.38, 0.51]7.3[2.9, 13.1]0.50[0.44, 0.56]
Qwen3.8-27B1M context, xhigh effort0.44[0.39, 0.49]6.9[1.6, 13.9]0.38[0.35, 0.42]
Luna*xhigh effort0.41[0.35, 0.46]4.1[0.8, 9.0]0.15[0.13, 0.18]
Qwen3.8-27B1M context, low effort0.36[0.31, 0.41]4.1[0.8, 9.0]0.26[0.23, 0.29]
Opus 5.5low effort0.33[0.29, 0.39]1.6[0.0, 4.9]0.64[0.53, 0.75]
Table 9: Every configuration measured on the test set, in descending order of pass rate, with 95% intervals over cases. Cost is relative to SRE-1 at a 1M context. * Missing a few rollouts.

Context length

Figure 41: Investigations use the full context window available. At 262k many investigations end near the window, so a longer window allows them to continue. We plot the peak context of each validation investigation (808 per checkpoint) at three windows. The dashed line marks the window, the solid line the median, and the vertical rule SRE-1’s checkpoint.

The median training investigation ended with 127k tokens in context over the first twelve steps, and with 218k over the last twelve. The training window was at most 262k tokens. On validation incidents at SRE-1’s checkpoint, the median investigation peaks at 238k tokens of context under a 262k window, 349k under 393k, and 441k under 1M (Figure 41).

We train SRE-1 at the base model’s native 262k-token window and serve it with up to 1M tokens with 4× YaRN scaling [35]. On validation incidents, the score rises with the window at almost every checkpoint (Figure 24a): 1M scores above 262k at 39 of 40. At SRE-1’s checkpoint the score is 0.60 at 262k, 0.63 at 393k, and 0.66 at 1M.

G. Qualitative analysis

The “qualitative judge”. Reading the data is one of the most useful practices in machine learning, and this run produced far more than a person can read: 409,600 trained rollouts with a median of 195k tokens of context each. To read it at scale, we built a hierarchy of LLM readers that we call the “qualitative judge”. It escalates the anomalies that it finds, including problems we did not anticipate. It has four levels:

  1. Read. A reader goes through one whole rollout (the prompt, every turn with its reasoning, the tool calls and their results, and the reference chain) and outputs notes: known failure modes, and open-ended observations of anomalies. Each note must quote its evidence verbatim, and a mechanical check drops any note whose quote is not in the transcript.
  2. Pool. A second level pools the notes of one training step into findings, with counts computed by code and not by the model.
  3. Compare. A third level compares steps and reports which findings improved, worsened, or persisted.
  4. Investigate. A fourth level is an agentic judge with tools: it takes a single finding, reads the run’s records, code, configuration history, and environment telemetry, and investigates it down to a proposed cause. It can file an escalation with a human.

Over this run the first level wrote 33,908 notes, on a 20% sample of each evaluation round and on sampled training rollouts. We treat what it reports as leads to check: every rate below was recomputed from the qualitative judge outputs.

Evidence retrieval. After RL, fewer rollouts fail because they never retrieved the deciding evidence. In the “qualitative judge”’s notes on the same incidents, the share of rollouts that failed because the deciding evidence was never retrieved fell from 66% for the base model to 46% for checkpoints 100 to 110, a drop of 20 points [13, 28] (inset of Figure 42b). Rollouts that retrieved the evidence but left it out of the answer rose by 10 points. The “qualitative judge” sees each rollout’s score, so this reading is not independent of the score gain.

Figure 42: RL changed how the model investigates: SRE-1 searches in parallel and answers in 39% fewer turns. The same validation incidents investigated by the base model (gray, calls stacked upward) and by SRE-1 (teal, downward). A column is a turn, a square is a tool call colored by tool family, and the circle is the answer, filled when it passes. (a) A typical pair, chosen without looking at scores. (b) Six incidents across the range of score gains. The inset gives turns, tool calls, and, on a judged sample, the share that never retrieved the deciding evidence.

Paired investigations. On the same validation incidents at a 262k window, SRE-1 searches in parallel where its base model makes one call at a time (Figure 42). SRE-1 makes two or more tool calls in 89% of its turns and answers in 39% fewer turns; the base model makes exactly one call in 88% of its turns. Its investigations nonetheless use more calls and more tokens: 74 tool calls per rollout against 55, and a mean peak context of 224k tokens against 133k, since it also reasons more than twice as long. SRE-1 often runs to the end of its window: in 38% of rollouts it answers only when the harness asks, which the base model never did. The case study below follows one incident through training.

Case study: a synthetic check that broke after a feature-flag rollout

Alert. A synthetic browser check on our own product paged: highlighting text in a report and asking a question about it failed in the test browser.

Reference chain. A configuration commit turned on a feature flag for threaded comments in two environments. With the flag on, a highlight-and-ask comment opens a thread panel, and the comment panel the check waits for never mounts, so its 15-second wait times out. The check failed continuously from a few hours after the commit.

Step 15. The rollout made 116 tool calls, one per turn. It read the test and the sidebar code, examined the check’s status series for many turns, and concluded that the failures began six days before the flag commit. At turn 108, it found the commit, noted the mismatch, and reexamined deployments from the earlier day. It attributed the failures to an unrelated frontend rollout. One scoring judge wrote: “Same symptom, wrong trigger and mechanism.” The answer scored 0.43.

Step 100. The rollout made 72 tool calls in 40 turns, two or three at a time in 28 of them. It read the test, the sidebar, and the panel code in paired calls, reached the flag definition and the same commit by turn 37, and based its chain on them: the flag routes a highlight-and-ask comment through the thread path, opening the thread panel instead of the comment panel. The answer scored 0.92.

Across 8 rollouts each, this incident’s mean score was 0.23 for the base model, 0.54 at step 15, and 0.84 for SRE-1, ten steps after the rollout above. It is one example and may not be typical.