SRE-1: Dominating the Pareto Frontier of Production Investigations with a 27B Model
November 18, 2026
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
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.
Root-cause analysis with SRE-1
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.
Related Work
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.
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
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 | |
|---|---|---|---|---|---|
| Origin | Internal | Internal | Synthetic | Vendor | Internal |
| Real fault | ✓ | ✓ | ✗ | ✗ | ✓ |
| Closeness to production | High | Medium | Low | Low | High |
| Answer known by construction | ✗ | ✗ | ✓ | ✓ | ✗ |
| Make telemetry tool calls | ✓ | ✓ | ✓ | ✓ | ✗ |
| Diversity | Medium | High | Medium | Low | High |
| Volume | Medium | Medium | Medium | Low | High |
| Cost | Low | Medium | Medium | High | Low |
| Setup effort | Medium | High | Medium | Medium | Low |
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.
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.
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
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
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).
| Component | Setting |
|---|---|
| Input | The 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) |
| Tool | bash 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 |
| Output | A 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 |
| Termination | A valid final answer, or an exhausted context of about 154K–162K tokens |
| Corpus | 1,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 |
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
and the final action submits an answer
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
Here
The mask improves RL stability: during a spike, the KL divergence between trainer and sampler (
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.
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).
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).
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].
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).
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).
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].
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.
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
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).
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
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.
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
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.
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.
| Model | Mean score | Pass rate | SRE-1’s lead in pass rate |
|---|---|---|---|
| SRE-1 | 0.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 model | 0.650 [0.613, 0.684] | 23.5% |
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
- Case selection. The pool over-represents alerts on which our production system, backed by frontier models, scored lower, which can favor SRE-1 against those models.
- Scope. We train and evaluate one task, finding a root cause from an alert in a single pass. On-call engineers do much more than this, and an ensemble takes longer than one investigation, which matters when an answer is needed in real time.
- Statistics. Bracketed intervals are 95% confidence intervals and are not adjusted for multiple comparisons.
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.
- 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
- 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
- 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.
- Anthropic. Introducing Claude Fable 5.1 and Claude Mythos 5.1. Blog post, www.anthropic.com/claude-fable-and-mythos-5-1, 2026.
- Anthropic. Introducing Claude Fable 5.2 and Claude Mythos 5.2. Blog post, www.anthropic.com/claude-fable-and-mythos-5-2, 2026.
- Anthropic. Introducing Claude Haiku 5.5. Blog post, www.anthropic.com/claude-haiku-5-5, 2026.
- Anthropic. Introducing Claude Opus 5.5. Blog post, www.anthropic.com/claude-opus-5-5, 2026.
- Betsy Beyer, Chris Jones, Jennifer Petoff, and Niall Richard Murphy, editors. Site Reliability Engineering: How Google Runs Production Systems. O’Reilly Media, 2016.
- William Brown.
verifiers: Environments for LLM reinforcement learning. Software, github.com/PrimeIntellect-ai/verifiers, 2025. - 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.
- 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.
- 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.
- 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.
- Cursor Research. Composer 2 technical report. arXiv preprint arXiv:2603.24477, 2026.
- Cursor Team. Introducing Composer 2.5. Blog post, cursor.com/blog/composer-2-5, 2026.
- 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.
- DeepSeek-AI. DeepSeek-V4: Towards highly efficient million-token context intelligence. arXiv preprint arXiv:2606.19348, 2026.
- DeepSeek-AI. DeepSeek-V4.1-Flash: Pushing the limits of KV cache compression. arXiv preprint arXiv:2609.19969, 2026.
- 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.
- 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.
- Leo Gao, John Schulman, and Jacob Hilton. Scaling laws for reward model overoptimization. In ICML, 2023. arXiv:2210.10760.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Peter Menzies and Helen Beebee. Counterfactual theories of causation. In The Stanford Encyclopedia of Philosophy, revised 2024. plato.stanford.edu/entries/causation-counterfactual.
- 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.
- The Microsoft AI Team. MAI-Thinking-1: Building a hill-climbing machine. Technical report, Microsoft AI, microsoft.ai/pdf/mai-thinking-1.pdf, 2026.
- MiniMax. MiniMax-M1: Scaling test-time compute efficiently with lightning attention. arXiv preprint arXiv:2506.13585, 2025.
- OpenAI. GPT-5.6 Luna. Model documentation, developers.openai.com/api/docs/models/gpt-5.6-luna, 2026.
- OpenAI. GPT-6 Astra. Model documentation, developers.openai.com/api/docs/models/gpt-6-astra, 2026.
- OpenAI. GPT-6.1 Sol. Model documentation, developers.openai.com/api/docs/models/gpt-6.1-sol, 2026.
- Arjun Panickssery, Samuel R. Bowman, and Shi Feng. LLM evaluators recognize and favor their own generations. In NeurIPS, 2024. arXiv:2404.13076.
- Bowen Peng, Jeffrey Quesnelle, Honglu Fan, and Enrico Shippole. YaRN: Efficient context window extension of large language models. In ICLR, 2024. arXiv:2309.00071.
- 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.
- Prime Intellect.
prime-rl. Software, github.com/PrimeIntellect-ai/prime-rl, 2025. - Prometheus Authors. Alerting (best practices). Documentation, prometheus.io/docs/practices/alerting, accessed November 2026.
- Qwen Team. Qwen3.8-27B. Model card, huggingface.co/Qwen/Qwen3.8-27B, 2026.
- John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
- John Schulman. Approximating KL divergence. Blog post, joschu.net/blog/kl-approx.html, 2020.
- 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.
- 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.
- 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.
- Splunk and Oxford Economics. The hidden costs of downtime. Report, Splunk; announced in newsroom.cisco.com, 2026.
- Thinking Machines Lab. Inkling: Our open-weights model. Blog post, thinkingmachines.ai/news/introducing-inkling, 2026.
- 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.
- 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.
- 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.
- 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.
- Xiaomi LLM-Core Team. MiMo-V2.6: Scaling reinforcement learning towards self-improvement. arXiv preprint arXiv:2610.11959, 2026.
- 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.
- 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.
- 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.
- 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
| Source | Origin | Share of 1,503-incident dataset | Share of 904-incident dataset | Served from | Reference chain | Base model never solves | Strongest agent solves |
|---|---|---|---|---|---|---|---|
| Live incidents | Internal | 23% | 31% | Live read-only backends and restored snapshots | Multi-agent system | 91% | 69% |
| Incident replays | Internal | 34% | 17% | Preserved telemetry | Multi-agent system | 88% | 75% |
| Synthetic environments | Synthetic | 35% | 44% | Restored snapshots | By construction | 67% | 85% |
| Licensed environments | Vendor | 8% | 8% | Restored snapshots | By construction | 64% | 82% |
Quality checks
| Check | An incident is dropped when | Excluded |
|---|---|---|
| Reference-chain quality | A link restates a symptom or a mitigation instead of following from cited evidence, or pre-alert telemetry does not support the chain | 28 |
| Solvability | No evidence path reaches the reference chain: the strongest agent never solves it, its best rollout scores below 0.6, and a blind tracer fails | 4 |
| Human review | An issue was flagged | 48 |
| Leakage | Code history, tickets, chat, documents, metric names, or recorded rollouts give away the answer in a way a real investigation would not see | 63 |
| Deduplication | It is similar to another alert and root cause | 9 |
| Decontamination | It shares an incident, or a template whose answer carries over, with a held-out evaluation set | 4 |
| Too easy | Strong model and the RL base model both have high pass rate | 4 |
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
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.
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.
C. Additional training details
- Advantages and weighting. Advantages are centered within each group and scaled by a running estimate of each environment’s reward standard deviation, chosen because the batch’s standard deviation moved 11% to 14% per step in our runs, and the step size with it, while each group’s own is small on very easy or very hard prompts and so inflates their advantages [25]; every rollout gets equal total weight, and no token weighs more than 10 times a token of the batch’s longest rollout.
- Staleness. Sampling overlaps training with a staleness bound of 2 steps. Of trained rollouts, 2% were 0 steps stale, 47% were 1 step stale, and 51% were 2 steps stale, measured from their starting weights.
- Budgets. Each randomized group draws 196,608–260,096 tokens of context, since in earlier draws the solve rate fell by 3 to 6 points below about 197k, and 30–160 turns, with a 16,642-token answer reserve.
- Variance filtering. We drop groups whose scores have a standard deviation below 0.05, which is mostly judge noise, or no score of 0.6 or more, so that training does not reinforce incidents the model did not fully solve.
- Numerics. Master weights and Adam moments are fp32. For 93.6% of the base model’s weights one step at our learning rate is smaller than half a bf16 spacing, so the policy’s bf16 weights only change after several steps.
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.
| # | Ablation | Result |
|---|---|---|
| Changes that helped | ||
| 1 | Capping 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* |
| 2 | Reserving room for a full final turn and the answer | +0.14 [0.12, 0.16]* |
| 3 | Sampling at temperature 1 instead of 0.6 | +0.12 [0.10, 0.14]* |
| 4 | A 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† |
| 5 | fp32 gradient accumulation (Figure 29) | +0.026 at step 25 [0.012, 0.040]‡ |
| 6 | Dense 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 |
| 7 | A newer dataset with more incidents (904 → 1,025) | +0.012 [0.004, 0.019] |
| 8 | One 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]) |
| 9 | A continuous judge score instead of a binary pass | A 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 |
| 10 | A 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 | ||
| 11 | A KL anchor to the sampler | −0.039 [−0.055, −0.024]: it slowed learning |
| 12 | PPO’s clip [40] instead of CISPO | PPO scored 0.036 higher after 10 steps [0.013, 0.059], one run each; we kept CISPO, following ScaleRL* |
| 13 | Starting from supervised fine-tuning, first study | Started 0.08 higher and led by 0.034 after 15 steps [0.023, 0.045] |
| 14 | A budget-relative penalty in the reward | −0.027 [−0.036, −0.017] |
| 15 | Withholding credit for citation mistakes | −0.020 [−0.028, −0.011]: dense credit does not always help |
| 16 | Supplying extra written knowledge about the environment | −0.016 [−0.024, −0.008] |
| 17 | Stacking four single changes | −0.012 against its own baseline [−0.021, −0.004]: effects did not add |
| 18 | Stronger speed incentives in the reward | −0.012 [−0.021, −0.003] |
| 19 | SAPO’s soft gate instead of CISPO [18] | No significant difference after 10 steps (+0.022 [−0.005, 0.047])* |
| 20 | An instruction-only nudge | No significant difference (+0.012 [−0.008, 0.030])* |
| 21 | 64 rollouts per prompt instead of 32 | No significant difference (−0.009 [−0.027, 0.009])† |
| 22 | Synchronous training instead of asynchronous | No significant difference (+0.006 [−0.020, 0.033]); we keep asynchronous training because synchronous stepping idles whichever side is faster* |
| 23 | Starting from supervised fine-tuning, second study | Started 0.09 higher; no significant lead after 15 steps (+0.006 [−0.012, 0.025]) |
| 24 | A higher minimum context | No significant difference (+0.005 [−0.004, 0.014]) |
| 25 | A notice of the remaining budget | No significant difference (+0.003 [−0.017, 0.022])* |
| 26 | The newer dataset, on the next recipe | No significant difference (−0.002 [−0.010, 0.005]) |
| 27 | A cost on tool calls | No significant difference (+0.002 [−0.005, 0.010]) |
| 28 | Other precision changes | No significant difference (−0.001 [−0.011, 0.008]) |
| 29 | Prompt-balanced loss weighting | No significant difference (0.000 [−0.007, 0.008]) |
| 30 | A larger fixed budget | More turns, no more incidents solved* |
| 31 | A fork that reset the optimizer state | Weights moved less over the next 20 steps (one pair; score not compared) |
| 32 | Telemetry simulated by a model | Picked the better of two models only 66% of the time against live runs [54%, 75%], so we removed it |
| 33 | Reference chains written by experts instead of the multi-agent system | No significant change in score (0.012 [−0.013, 0.034]) |
E. Infrastructure and operations
| Run | Value |
|---|---|
| Base model | Qwen3.8-27B, dense, RL from the base weights |
| Hardware | Up to 512 GPUs: 192 for the trainer, 320 for samplers (160 for the last three steps) |
| Duration | 7.4 days, restarts included; 86.6k GPU-hours; median step 47 min |
| Rollouts | 812,695 run to completion; 409,600 trained: 311,680 investigations, 97,920 syntheses |
| Tool use | 51.5 million tool calls by the model and 81B tokens of tool results read, over all completed rollouts |
| Tokens | 76.2B trained, 20.8B of them generated by the policy; 2.5T prompt tokens processed |
| Median rollout | 195k tokens of context, 26 turns, 63 tool calls |
Fault tolerance
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
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.
F. Additional results
| Model | Setting | Mean score | Pass rate (%) | Cost (×) | |||
|---|---|---|---|---|---|---|---|
| SRE-1 ensemble | ensemble of 5 | 0.83 | [0.79, 0.87] | 71.4 | [57.1, 83.7] | 7.33 | [6.49, 8.20] |
| SRE-1 ensemble | ensemble of 3 | 0.80 | [0.76, 0.84] | 59.9 | [46.3, 72.8] | 3.76 | [3.30, 4.21] |
| SRE-1 ensemble | ensemble of 2 | 0.76 | [0.72, 0.80] | 50.2 | [37.6, 62.8] | 2.72 | [2.37, 3.07] |
| SRE-1 | 1M context | 0.70 | [0.66, 0.74] | 38.8 | [28.2, 49.8] | 1.00 | [0.87, 1.13] |
| SRE-1* | 1M context, guidance to work faster | 0.67 | [0.62, 0.72] | 36.2 | [25.2, 47.5] | 0.67 | [0.58, 0.76] |
| SRE-1 | 524k context | 0.66 | [0.62, 0.71] | 33.1 | [22.0, 44.1] | 0.46 | [0.42, 0.51] |
| SRE-1 | 393k context | 0.61 | [0.56, 0.66] | 24.1 | [15.5, 33.1] | 0.33 | [0.30, 0.35] |
| SRE-1 | 262k context, 60-turn cap | 0.54 | [0.48, 0.60] | 15.5 | [8.2, 24.1] | 0.19 | [0.18, 0.20] |
| Fable 5.2* | xhigh effort | 0.84 | [0.81, 0.87] | 71.0 | [60.4, 80.4] | 11.58 | [10.58, 12.61] |
| Opus 5.5 ensemble | ensemble of 5 | 0.83 | [0.78, 0.87] | 65.3 | [51.0, 77.5] | 33.25 | [30.20, 36.54] |
| Fable 5.1 | xhigh effort | 0.73 | [0.69, 0.78] | 48.2 | [38.0, 59.2] | 11.91 | [11.02, 12.88] |
| Opus 5.5 | xhigh effort | 0.74 | [0.70, 0.78] | 47.8 | [37.1, 58.8] | 5.00 | [4.47, 5.57] |
| Astra* | xhigh effort | 0.70 | [0.64, 0.75] | 38.4 | [26.9, 49.8] | 8.77 | [7.64, 10.03] |
| Sol 6.1 | xhigh effort | 0.64 | [0.57, 0.69] | 29.8 | [19.6, 40.4] | 1.30 | [1.14, 1.47] |
| DeepSeek V4.1 Flash 1017 | xhigh effort | 0.50 | [0.45, 0.55] | 8.6 | [2.9, 15.5] | 0.23 | [0.20, 0.25] |
| Haiku 5.5 | xhigh effort | 0.44 | [0.39, 0.49] | 8.2 | [2.9, 14.3] | 0.60 | [0.55, 0.65] |
| Qwen3.8-27B | 1M context, xhigh effort | 0.44 | [0.39, 0.49] | 6.9 | [1.6, 13.9] | 0.38 | [0.35, 0.42] |
| Luna* | xhigh effort | 0.41 | [0.35, 0.46] | 4.1 | [0.8, 9.0] | 0.15 | [0.13, 0.18] |
| Model | Setting | Mean score | Pass rate (%) | Cost (×) | |||
|---|---|---|---|---|---|---|---|
| SRE-1 ensemble | ensemble of 5 | 0.83 | [0.79, 0.87] | 71.4 | [57.1, 83.7] | 7.33 | [6.49, 8.20] |
| Fable 5.2* | xhigh effort | 0.84 | [0.81, 0.87] | 71.0 | [60.4, 80.4] | 11.58 | [10.58, 12.61] |
| Opus 5.5 ensemble | ensemble of 5 | 0.83 | [0.78, 0.87] | 65.3 | [51.0, 77.5] | 33.25 | [30.20, 36.54] |
| Fable 5.2 | high effort | 0.81 | [0.78, 0.84] | 64.9 | [54.7, 74.7] | 8.83 | [8.05, 9.66] |
| Opus 5.5 ensemble | ensemble of 2 | 0.79 | [0.75, 0.84] | 61.2 | [46.9, 73.5] | 12.27 | [11.14, 13.48] |
| SRE-1 ensemble | ensemble of 3 | 0.80 | [0.76, 0.84] | 59.9 | [46.3, 72.8] | 3.76 | [3.30, 4.21] |
| Opus 5.5 ensemble | ensemble of 3 | 0.80 | [0.76, 0.85] | 59.2 | [44.9, 73.5] | 18.03 | [16.06, 20.11] |
| SRE-1 ensemble | ensemble of 2 | 0.76 | [0.72, 0.80] | 50.2 | [37.6, 62.8] | 2.72 | [2.37, 3.07] |
| Fable 5.1 | xhigh effort | 0.73 | [0.69, 0.78] | 48.2 | [38.0, 59.2] | 11.91 | [11.02, 12.88] |
| Opus 5.5 | xhigh effort | 0.74 | [0.70, 0.78] | 47.8 | [37.1, 58.8] | 5.00 | [4.47, 5.57] |
| SRE-1 | 1M context | 0.70 | [0.66, 0.74] | 38.8 | [28.2, 49.8] | 1.00 | [0.87, 1.13] |
| Astra* | xhigh effort | 0.70 | [0.64, 0.75] | 38.4 | [26.9, 49.8] | 8.77 | [7.64, 10.03] |
| Fable 5.2* | medium effort | 0.72 | [0.69, 0.76] | 38.3 | [28.1, 49.3] | 5.25 | [4.74, 5.81] |
| SRE-1* | 1M context, guidance to work faster | 0.67 | [0.62, 0.72] | 36.2 | [25.2, 47.5] | 0.67 | [0.58, 0.76] |
| SRE-1 | 524k context | 0.66 | [0.62, 0.71] | 33.1 | [22.0, 44.1] | 0.46 | [0.42, 0.51] |
| Sol 6.1 | xhigh effort | 0.64 | [0.57, 0.69] | 29.8 | [19.6, 40.4] | 1.30 | [1.14, 1.47] |
| Fable 5.2 | low effort | 0.67 | [0.63, 0.71] | 29.4 | [20.4, 38.8] | 4.38 | [3.92, 4.90] |
| Astra* | high effort | 0.66 | [0.60, 0.71] | 29.2 | [18.4, 40.2] | 7.76 | [6.80, 8.81] |
| Opus 5.5 | high effort | 0.65 | [0.60, 0.69] | 26.5 | [18.4, 35.5] | 3.06 | [2.70, 3.44] |
| Astra* | medium effort | 0.61 | [0.55, 0.67] | 24.2 | [14.0, 34.7] | 5.83 | [5.15, 6.53] |
| SRE-1 | 393k context | 0.61 | [0.56, 0.66] | 24.1 | [15.5, 33.1] | 0.33 | [0.30, 0.35] |
| Sol 6.1 | high effort | 0.63 | [0.56, 0.69] | 24.1 | [14.7, 34.3] | 1.19 | [1.05, 1.32] |
| Sol 6.1 | medium effort | 0.57 | [0.51, 0.63] | 18.4 | [9.4, 27.8] | 0.86 | [0.75, 0.98] |
| SRE-1 | 262k context, 60-turn cap | 0.54 | [0.48, 0.60] | 15.5 | [8.2, 24.1] | 0.19 | [0.18, 0.20] |
| Opus 5.5 | medium effort | 0.59 | [0.54, 0.63] | 15.5 | [8.2, 24.1] | 2.41 | [2.16, 2.68] |
| DeepSeek V4.1 Flash 1017 | xhigh effort | 0.50 | [0.45, 0.55] | 8.6 | [2.9, 15.5] | 0.23 | [0.20, 0.25] |
| Haiku 5.5 | xhigh effort | 0.44 | [0.39, 0.49] | 8.2 | [2.9, 14.3] | 0.60 | [0.55, 0.65] |
| Astra | low effort | 0.48 | [0.42, 0.53] | 7.8 | [2.5, 14.3] | 3.26 | [2.87, 3.66] |
| Sol 6.1 | low effort | 0.45 | [0.38, 0.51] | 7.3 | [2.9, 13.1] | 0.50 | [0.44, 0.56] |
| Qwen3.8-27B | 1M context, xhigh effort | 0.44 | [0.39, 0.49] | 6.9 | [1.6, 13.9] | 0.38 | [0.35, 0.42] |
| Luna* | xhigh effort | 0.41 | [0.35, 0.46] | 4.1 | [0.8, 9.0] | 0.15 | [0.13, 0.18] |
| Qwen3.8-27B | 1M context, low effort | 0.36 | [0.31, 0.41] | 4.1 | [0.8, 9.0] | 0.26 | [0.23, 0.29] |
| Opus 5.5 | low effort | 0.33 | [0.29, 0.39] | 1.6 | [0.0, 4.9] | 0.64 | [0.53, 0.75] |
Context length
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:
- 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.
- Pool. A second level pools the notes of one training step into findings, with counts computed by code and not by the model.
- Compare. A third level compares steps and reports which findings improved, worsened, or persisted.
- 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.
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.