DevRev's GPT-6.1 Sol Story Is Really a Story About Where GPT-6 Astra Isn't

OpenAI published a customer story this week titled "DevRev delivers autonomous self-service with GPT-6.1 Sol", and the most informative sentence in it is not about GPT-6.1 Sol at all. It is the one where DevRev's sales engineers are said to use GPT-6 Astra to build demos for conference booths. DevRev's chief technology officer, Ahmed Bashir, describes a company that has split its model estate in two: the mid-tier model carries the production support path, and the frontier model carries the thing a prospect looks at for ninety seconds. That is a more useful piece of evidence than any benchmark in the post, because it is a deployment decision made by someone with a bill to pay.

The timing matters. GPT-6.1 Sol shipped on 29 September 2026 at DevDay, one week after GPT-6 Sol, at $2.00 per million input tokens and $10.00 per million output tokens. DevRev's own write-up of the OpenAI partnership carries an update stamp of 2 November 2026, and the customer story is the first time a named production service has put the mid-tier model, rather than the flagship, on the customer-facing path. It is not a launch. It is the first job reference.

What DevRev actually runs

DevRev builds two products on the same substrate. Computer is the AI teammate that answers and acts across business data; Operator is the agent that takes an approved action or routes a request to the right person. Both need the same three things before a model is allowed near a customer: company context, permissions that match a person's role, and actions that can be undone. The model supplies reasoning, planning and tool selection. DevRev's harness supplies the rest, and Agent Studio is where a customer describes in conversation how a tool should behave, then pins the parts that must not vary with fixed rules.

Two properties in the story are worth more than the praise. Actions are reversible. Answers cite their sources. Those are the two failure modes that stop enterprises from letting an agent close a ticket, and DevRev is claiming both as product behaviour rather than model behaviour. If you are evaluating any self-service agent, those are the questions to ask, and no leaderboard answers them.

The number that will get attached to this story is from July, and it isn't about Sol

Search for coverage of DevRev and OpenAI and you will find a striking pair of figures: 48% more accurate, and 4.4 times fewer tokens per correct response. They are real, they are published, and they have nothing to do with GPT-6.1 Sol.

Those figures come from a 9 July 2026 release announcing Enterprise-Bench, an open enterprise-agent benchmark DevRev built with the Laude Institute and published on the Harbor harness. In that comparison, DevRev's Computer scored 94.3% against 63.6% on the XL dataset, and used roughly 5,598 tokens per correct response against 24,461. The comparison was explicitly harness against harness, with both systems running the same underlying model. DevRev attributed the gap to its retrieval and shared-memory architecture, not to the model underneath. It was also benchmarked against Claude Code, not against anything OpenAI shipped in September.

The OpenAI customer story mentions Enterprise-Bench, and Bashir says GPT-6.1 Sol performs well on it. That is a qualitative statement. No score is given, no dataset slice, no comparison. Anyone bolting the July numbers onto the November story is measuring a different thing on a different model in a different quarter. The honest reading is narrower and still interesting: DevRev has a benchmark it built for exactly this decision, and it declined to publish a Sol row on it.

What the story does not say

There is no resolution rate, no ticket volume, no latency percentile, no token count and no price in the OpenAI post. For a customer story about autonomous self-service, that is the whole scoreboard missing.

The nearest published figure is DevRev's BILL proof of concept, where BILL reported a 70% AI resolution rate on real customer queries using its own evaluation. DevRev's materials also cite a 77% token reduction and a drop from about nine minutes to about 1.5 minutes on multi-step questions, measured against its own earlier approach. These are vendor-reported and unreproduced, and none of them is tied to the model generation now in production. Treat them as the shape of the claim, not the size of it.

Bashir's own constraint is the one to hold onto: "These things have to be able to run and complete themselves in seconds, not minutes." A support interaction that takes twenty minutes of reasoning is not self-service, whatever it scores. That sentence explains the model choice better than any benchmark table.

The arithmetic a support desk can check

Take a routine ticket: 20,000 input tokens of retrieved context, 2,000 output tokens including reasoning. On GPT-6.1 Sol's list price that is $0.04 of input and $0.02 of output, so about six cents. The same request on GPT-6 Astra, at $10.00 input and $50.00 output, is $0.20 plus $0.10, or about thirty cents. Same task, five times the bill.

Six cents is a floor rather than a forecast. Reasoning tokens are billed as output, retries are billed twice, and any tool loop multiplies both. But the ratio is the point, and it survives all three caveats. OpenAI's own vendor-reported cost figures point the same way: on Terminal-Bench Science 0.1, OpenAI put GPT-6.1 Sol at $5.47 per task against $23.80 for GPT-6 Astra and $23.21 for Claude Opus 5.5, with Sol scoring 57.02% at max effort against Astra's 68.1%. You are buying eleven points of capability for four times the money, and on a support queue the eleventh point is usually a better paraphrase, not a resolved ticket.

This is the calculation the OrcaRouter pricing model is built around: provider list price passed through with no markup, so a rate like $2.00 and $10.00 is the number you pay, and a vendor price change lands the same day rather than at the next contract renewal. Both models sit behind one key, which means the split DevRev has made in its architecture — cheap model on the volume path, expensive model where the answer is the product — is a routing decision rather than a second procurement. For the steps where a wrong tool call is expensive, failover to a stronger model on a per-request basis is the difference between a bad afternoon and a bad week.

Why the mid-tier model gets the production path

The instinct is to read this as a cost story. It is partly a latency story. GPT-6.1 Sol runs with reasoning always on across five effort levels, low through max, defaulting to medium, and it does not accept temperature or top_p at all. That removes the tuning knob most teams reach for when an agent feels slow, and leaves effort level as the throttle. Between low and max, the difference in time to a first answer token is measured in minutes, not milliseconds.

The independent numbers sit where you would expect for a model in this slot. On Artificial Analysis Intelligence Index v5.0.1, GPT-6.1 Sol scores 55 at max effort, at 56 tokens per second, $1.27 per completed index task and 63.7 million output tokens across the run. On our own seven-day telemetry it shows a 937 ms median time to first token, a 5.7% error rate and 39.5 tokens per second of output, which is the sort of profile a support flow can be built on: not the fastest model available, but predictable enough that a queue can be sized around it.

The context window is the other half of the choice. At 1,050,000 tokens with a 128,000-token output ceiling, a case file, its history and the retrieved knowledge all fit in one request. That is what makes an agent that reasons "across live data" possible without an elaborate chunking layer — and it is the part of the spec sheet that a 70% resolution rate actually depends on.

What would turn this into a case study

Three things would move this from a logo on a page to evidence you can plan against. A published resolution rate for Operator, on a named dataset, with the human-escalation rate beside it. A latency distribution rather than an average, because p95 is where self-service breaks. And a Sol-versus-Astra ablation on Enterprise-Bench, since DevRev already owns the harness and has already shown it will publish results when they favour its architecture.

Bashir points at two things he wants next: the Decisions API, for the small judgement calls that are expensive to encode as rules but do not need deep reasoning, and Ultrafast, OpenAI's 6× speed tier at $12.00 input and $60.00 output per million tokens, purchasable since 8 October. Both are attempts to buy latency without buying intelligence, which is the correct instinct for a support queue and the opposite of what most agent roadmaps chase.

The pattern to watch is not DevRev specifically. It is that the first named production deployment of GPT-6.1 Sol put the cheap model where customers are and the expensive model where prospects are. If that becomes the normal shape of an enterprise agent stack — a workhorse on the volume path, a flagship for the demo — then the interesting question for every vendor stops being which model is smartest and starts being how cleanly you can move a request between them.