NewKepler launches 20 November.Kepler is live.See Kepler

SRE-1 explained: what Resolve AI's new 27B model means for AI SRE

AI Operations11 min readRubixKube SRI

Resolve AI trained SRE-1, a 27B model, to find the root cause of production incidents. A plain-English read of the paper: the results, the training method, the limits, whether you can run it, and what it means for AI SRE.

SRE-1 explained: what Resolve AI's new 27B model means for AI SRE
On this page

During training, one of Resolve AI's agents was investigating a past incident when it found the hash of a commit made after the alert. It opened the commit, read the fix for the very incident it was investigating, wrote that up as the root cause, and scored high.

That one rollout is the whole problem of teaching a model to run production. The answer is usually written down somewhere, after the fact, and a model that can read it will. Resolve AI's SRE-1 paper is, among other things, a careful account of closing that door. It is the most thoroughly reported piece of work the AI SRE category has produced so far, and it deserves a careful read.

In short. SRE-1 is a 27B model, trained with reinforcement learning from the open Qwen3.8-27B weights, to find the root cause of a production alert. On 49 hard cases from live production, one SRE-1 investigation passes 38.8% of the time, up from 6.9% for the base model. An ensemble of five passes 71.4%, level with the strongest frontier model tested, at 37% less cost. The weights are not public. The paper's own ablations show that harness settings moved the score more than any training change. And the benchmark measures a single pass with no memory of earlier incidents, so it does not say what happens the second time the same thing breaks.

What is SRE-1?

SRE-1 is a dense 27-billion-parameter model. Resolve AI post-trained it with reinforcement learning on one task: start from an alert, query the production tools an engineer would query, and return a causal chain. A caused B, which caused C, with evidence cited for every link.

The final run took 7.4 days on up to 512 GPUs, about 86,600 GPU-hours. It ran 200 training steps, and the released model is the checkpoint from step 110. Along the way the model completed 812,695 investigations and made 51.5 million tool calls. The search for the recipe was much bigger than the run: 60 training runs, more than 660,000 GPU-hours and 11 million judge calls. Eleven primary contributors did this by directing coding agents. One lead researcher's logs show 16,182 agents over 19 weeks, most of them started by other agents.

The training data was 1,503 incidents investigated through live tools, plus 7,716 problems built from 1,774 saved investigations. The incidents came from four places. Just under a quarter were live incidents in Resolve's own production. A third were replays of their own incidents, captured while the telemetry still existed. Another third were synthetic environments built by agent swarms, with planted faults and known answers. The rest, 8%, were licensed environments from outside vendors. The authors are clear that the synthetic cases are the easy ones and the real ones are hard.

SRE-1 benchmark results

The test set is 49 cases from live production, each run five times. Cost is relative to one SRE-1 investigation.

  • Qwen3.8-27B, the base model: pass rate 6.9%, relative cost 0.38
  • SRE-1, one investigation, 1M context: pass rate 38.8%, relative cost 1.00
  • SRE-1, ensemble of three: pass rate 59.9%, relative cost 3.76
  • SRE-1, ensemble of five: pass rate 71.4%, relative cost 7.33
  • Opus 5.5, xhigh effort: pass rate 47.8%, relative cost 5.00
  • Opus 5.5, ensemble of five: pass rate 65.3%, relative cost 33.25
  • Fable 5.2, xhigh effort: pass rate 71.0%, relative cost 11.58
SRE-1 against frontier models: pass rate against cost, from Table 9 of the paper
Drawn by RubixKube from the SRE-1 technical paper.

Three things to take from this.

The training worked. A fivefold gain on a single pass is real. SRE-1 solved 32 of the 49 cases at least once, against 6 for the base model. The test set was held out until the end and was not used to pick the checkpoint. That is how it should be done and often is not.

The frontier claim is about cost, not ceiling. One SRE-1 investigation passes as often as Fable 5.2 at medium effort for under a fifth of the price. To match Fable 5.2 at its strongest, SRE-1 needs five investigations merged into one answer, and then it wins on cost by 37%. That is a good result. It is also a result about running many cheap attempts, which takes longer, and the authors note that an ensemble is slower when an answer is needed now.

The test set has a known tilt. The limitations section says the pool over-represents alerts on which Resolve's own production system, which runs on frontier models, had scored lower. Of 175 candidate alerts, 67 survived telemetry expiry and 49 survived the audit. Two were removed because neither model could solve them. So this is not a general benchmark of incident response. It is 49 hard alerts that frontier models had already struggled on.

There is a second result worth knowing. On offline synthesis, where the model gets the saved evidence of an earlier investigation and no live tools, SRE-1 passes 51.7% of 73 problems, against 44.5% for Opus 5.5 and 39.0% for Fable 5.2. This is the skill that makes the ensembles work. Merging five investigations is the same job as reading five folders of evidence.

How the answers were graded

Every causal chain is scored from 0 to 1 by LLM judges against a reference chain. Three model families are averaged so no judge favours its own output. A score of 0.8 or more counts as a pass. The judging prompt was tuned against 87 chains labelled by on-call engineers.

The reference chains were not written by experts. A multi-agent system built them from the raw evidence, because production telemetry expires in weeks, faster than people can write answers. On 27 incidents, an evaluation team of SREs judged the system's chain as good as an expert's on 26, and swapping in expert-written references moved the mean score by 0.012.

So the grading is model on model, calibrated against people once. The paper is open about this. It is the thing to keep in mind when you read any pass rate in this category, from any vendor, including us.

How SRE-1 was trained

The methods section is where the value is for anyone building in this space. Six things stand out.

Time pinning. By the time you train on a past incident, the fix is in a commit, the cause is in a ticket, and the model can read both. So every tool was either made to answer as of the alert time or dropped from training. Leakage was still the biggest reason incidents were excluded: 63 of the 160 dropped.

Reward hacking. Early models restated the alert as the first causal link, listed ruled-out causes nobody had proposed, and cited a README they never opened. The fix was 13 judges drawn at random across providers, so the policy cannot learn one grader's taste, plus a check that every citation resolves to a real source. Of 3.8 million citations in trained rollouts, 98.2% did.

Dense credit. Instead of rewarding or punishing a whole investigation, they reduce credit at the exact turn where the model made a tool mistake, repeated itself, or exceeded the call limit. Those mistakes became 12 to 343 times rarer.

The numerics bug. Gradients were being accumulated in bf16 instead of fp32, losing an estimated 12.6% of additions on one recorded step. Fixing it made the gain over the base model 24% larger. Twenty reward and advantage changes that month did less.

Parallel calling collapsed. In four earlier runs the model fell to one tool call per turn and reinforcement learning could not bring it back, because once every rollout behaves the same there is no variation left to reinforce. They forked the run from before the collapse and added a temporary penalty.

Real tool failures stayed in. 18.1% of training investigations had at least one failed tool call, from timeouts and rate limits in real backends. They injected none and dropped none, because production fails like that.

The result that is not in the announcement

The appendix compares all 33 ablations. Its own summary: harness and sampling settings moved the score most, by 0.12 to 0.16, and no training change produced a difference of 0.05 or more.

What moved SRE-1's score: harness settings against training changes, from Table 6 of the paper
Drawn by RubixKube from the SRE-1 technical paper.

Raising the cap on how much of a tool result enters the model's context, from 25,000 to 100,000 characters, dropped the mean score from 0.53 to 0.37. Reserving room for the final answer was worth 0.14. Sampling temperature was worth 0.12. The largest training change, the importance-ratio band, was worth 0.049. The context window alone moved the single-pass pass rate from 15.5% at 262k tokens to 38.8% at 1M.

One more row from that table deserves attention, because it cuts against an easy story. Supplying extra written knowledge about the environment made the score slightly worse, by 0.016. Dumping more text into the prompt is not the same as the system knowing more.

Now read the problem setting. The agent starts from an alert and a knowledge graph of the environment that the harness supplies. The model does not discover the system. The harness hands it the map, the tools and the budget, and the model investigates inside that.

This is the point for anyone evaluating the category. The model is now the part you can rent. The base weights were open, the GPUs were rentable, and the authors say the part they could not rent or download was the environments and the expertise to build them. Their own ablations prove it. The scarce thing is context, and context is accumulated at a customer, not trained in a lab.

Can you run SRE-1 yourself?

Not today. The paper and the launch post do not announce a release of the weights, and at the time of writing Resolve AI's Hugging Face page lists no models. The base model, Qwen3.8-27B, is open, but SRE-1 is not. The only way to see it work is inside Resolve's product. Their Primary On-call offer, three months free, is the route if you want to test it on your own alerts.

What we take from it, honestly

A note from Priyank, in his own words.

First, the way they built it. The training system was written, launched and operated by coding agents under human direction. We build RubixKube the same way, as an agent first, proven in a harness, then moved into code. Seeing a lab do frontier-grade work with eleven people this way is confirmation, not news, but it is good to see it in print with numbers.

Second, the harness finding is our wrong-substrate argument proved from the other side. Same weights, different plumbing, a 0.16 swing. We have said for a year that the system around the model decides more than the model. Resolve has now measured it, on their own model, and published it.

Third, the written-knowledge row is a warning to us as much as anyone. Memory is not a longer prompt. If you hand a model everything you know, it does worse. Memory has to be retrieved for the incident in front of it, dated, small, and kept apart from the evidence it is being checked against. That is how we built learnings into RubixKube, and we have not proved ours on 49 cases either. SRE-1 raises the bar for how we have to.

Fourth, where we disagree. Resolve's framing is machines on call for humans, with the agent on the critical path and the human out of the loop. Our framing is infrastructure that heals itself, with you deciding how far. Same destination, different road. We think the road runs through staged trust that the team can see and pull back, and through the operator's own machine as much as the organisation's platform. That is why there are two ends to RubixKube.

Fifth, what we will do. We hold the conviction Resolve just spent 86,000 GPU-hours on: the model for this job should be trained on this job. We will train one when our incident corpus earns it, we will keep the model replaceable, and we will publish the number nobody has published yet, which is the next section.

The question the paper leaves open

SRE-1 investigates each alert in a single pass. Time pinning deliberately hides everything that happened after the alert, which for a repeat incident includes everything learned the first time. That is the right design for a clean benchmark. It is also the opposite of how a good on-call engineer works, and the paper does not report what happens the second time the same thing breaks at the same customer.

That curve is the one to ask for, from Resolve and from everyone else. The second-occurrence pass rate tells you whether a system is learning the system or only the craft. If it bends upward, the memory is doing its job and the model is a multiplier on it. If it is flat, you have a very good consultant who forgets you between visits.

Congratulations to the Resolve AI Labs team. This is the most carefully reported work the category has produced, and it makes the next year better for everyone on call.

Frequently asked questions

What is SRE-1?

SRE-1 is a 27B-parameter model from Resolve AI, trained with reinforcement learning to find the root cause of production alerts. It starts from the open Qwen3.8-27B weights and was announced on 18 November 2026.

How accurate is SRE-1?

On Resolve AI's test set of 49 hard live production cases, a single SRE-1 investigation passes 38.8% of the time. An ensemble of five investigations passes 71.4%. The base model passed 6.9%. These are pass rates on cases chosen because frontier models had scored lower on them, so they are not comparable to accuracy figures quoted for everyday alerts.

How does SRE-1 compare to frontier models?

A single SRE-1 investigation matches Fable 5.2 at medium effort for under a fifth of the cost. An ensemble of five SRE-1 investigations matches Fable 5.2 at its highest effort at 37% less cost, and beats an ensemble of five Opus 5.5 investigations, 71.4% to 65.3%, at about a quarter of the cost.

Is SRE-1 open source or open weight?

No. The paper and launch post do not announce a weights release, and Resolve AI's Hugging Face page lists no models at the time of writing. The base model, Qwen3.8-27B, is open. SRE-1 is used inside Resolve AI's own platform.

What is the difference between AI SRE and Site Reliability Intelligence?

AI SRE describes software that does the investigation work of a site reliability engineer: it reads the systems, finds the root cause and proposes the fix. Site Reliability Intelligence is the term RubixKube uses for the larger goal: infrastructure that understands itself, remembers what happened before, and over time fixes itself within limits the team sets. See What is an AI SRE and Compare AI SRE tools.

Does RubixKube use a domain-specific model?

RubixKube runs its agent, Rubix, on frontier and open models today, and is built so the model can be swapped without losing what the system has learned about an organisation's infrastructure. A model trained specifically for production investigation is the direction RubixKube shares with Resolve AI.

Stay updated

Get the latest insights on infrastructure reliability.

See how it works.

Book a 30-minute demo. No slides, just your stack.

Download Whitepaper