The 27B is fine.
This is the agent.
Both are Qwen3.8. Both carry 262,144 tokens of native context. Both take images and video. At rest the two are close, and we will say so below. The difference shows up on turn 40 of a long run, and in what can be measured about refusals — only one of the two cards publishes a refusal number, and it is not the 27B's.
Benchmarks are vendor-reported and are not a measurement of this endpoint. Sources are listed under every table on this page.
58.7 against 42.2, on the benchmark that pays at the end.
Sixteen and a half points. That is +39% relative, and the relative figure is the one to carry, because the absolute score of either model on a long-horizon suite is not portable to your repository.
Δ +16.5 points · +39% relative
27B scores: Qwen3.8-27B model card. Flash-Next scores: vendor-reported, agentic harness. Checked 2026-11. Neither is a measurement of this endpoint.
DeepSWE 1.1 does not ask for a function. It hands over a repository, an issue and a failing state, then waits. The repo is large, the issue is under-specified, and there is no clean stopping point where the work looks finished but is not — the grader checks the end state, so the whole trajectory has to stay coherent for as long as the task takes.
That is what the gap is measuring. A 16.5-point difference on a suite with delayed reward shows up less as better answers per turn and more as agents that close the run instead of agents that stop halfway, summarise their progress, and ask whether to continue. Turn 40 is where a run is won or lost, and neither model is rewarded for turn 3.
One caveat that belongs next to the number: neither figure is a measurement of this endpoint. Both are vendor scores on vendor harnesses, published on the two model cards. The comparison is honest, but it is a comparison of published scores, not of your workload.
The full table, including the rows that do not flatter us.
Twelve rows. Four are numerically comparable, one is a tie, and seven are asymmetric: one card publishes, the other does not. Those seven are not wins for anybody.
| Benchmark | Qwen3.8-27B | qwen-flash-next | Δ |
|---|---|---|---|
| DeepSWE 1.1 agentic coding | 42.2 | 58.7 | +16.5 |
| GPQA Diamond science | 89.2 | 91.7 | +2.5 |
| LiveCodeBench v6 code | 90.3 | 91.9 | +1.6 |
| SWE-bench Pro agentic coding | 61.7 | 62.5 | +0.8 |
| Context window | 262,144 native (to 1M) | 262,144 native (toward 1M) | tie |
| Max output | not published | 131,072 | — |
| Toolathlon Verified | not published | 73.5 | — |
| Terminal Bench 2.1 | 73.0 | not published | — |
| NL2Repo-Bench | 42.3 | not published | — |
| QwenSWEBench | 79.0 | not published | — |
| IFBench | 79.5 | not published | — |
| HLE | 30.8 | not published | — |
27B scores: Qwen3.8-27B model card. Flash-Next scores: vendor-reported, agentic harness. Checked 2026-11. Neither is a measurement of this endpoint.
Read the last seven rows as an absence, not a victory. Five of them are evals the 27B card publishes and ours does not — terminal work, repository generation, instruction following, hard reasoning. We are not going to put a dash in a column and let it read as zero: a dash means nobody measured, which is a different claim from a low score.
The context row is a tie and is marked as one. 262,144 native tokens on both sides, with extension paths beyond that on both sides. Nothing in this comparison is bought with a larger window, and the price of a tie is that it is not an argument.
Same suite, two bars, one delta.
Grey is the 27B. Acid is this build. The delta is printed on the label rather than implied by the length of a bar.
Bars are drawn to the published score, 0–100, so a two-point difference looks like a two-point difference. That is deliberate: on GPQA and LiveCodeBench these two models are practically adjacent, and a chart that exaggerates it would be a chart you cannot use.
Three of the four comparable rows are close. GPQA Diamond is +2.5, LiveCodeBench v6 is +1.6, SWE-bench Pro is +0.8. Those are real numbers and they are small, and stacking them into a narrative would be dishonest arithmetic — a model does not become three times better because three of its scores are ahead by a rounding error's worth.
The one row that is not close is DeepSWE 1.1, and it is the only row in the table that measures how a run ends rather than how a single turn is answered. That is why this page spends its evidence budget there.
There is a fourth bar we could draw and did not: speed. This build serves at roughly 94 tokens per second with a p50 time to first token of 1.78 s, but the 27B's card publishes no comparable serving figure, so a bar chart of latency would compare a measurement to an anecdote.
27B scores: Qwen3.8-27B model card. Flash-Next scores: vendor-reported, agentic harness. Checked 2026-11. Neither is a measurement of this endpoint.
SWE-bench Pro is a tie wearing a plus sign.
62.5 against 61.7. Eight tenths of a point, inside harness noise.
Run agentic repository benchmarks twice with a different scaffold and the same model will move further than 0.8 points. Scaffold choice, retry policy, how much of the test suite is visible to the agent, and how many attempts the harness allows all cost more than this delta. If a vendor presents +0.8 as a purchase reason, they are selling the shape of a table, not a capability.
And the score underneath is worth saying out loud: a 27B model at 61.7 on SWE-bench Pro is a serious model. It is not a small model doing a large model's impression. If your work is single-file patches with a clear specification, or code review where the context fits comfortably in a prompt, both of these models are more than adequate, and the decision should be made on hosting, price and support — not on this page.
The same restraint applies to GPQA Diamond and LiveCodeBench v6. +2.5 and +1.6 are within the range where a different sample of questions, a different prompt template, or a different reasoning effort setting can close or reverse the margin. We report them because they are published; we do not claim them as reasons.
27B scores: Qwen3.8-27B model card. Flash-Next scores: vendor-reported, agentic harness. Checked 2026-11. Neither is a measurement of this endpoint.
Three vision and computer-use evals we cannot answer.
The 27B card publishes a set of GUI and web-agent numbers. This build publishes none. That is a gap in evidence, and it is the 27B's to win.
| Eval | Qwen3.8-27B | qwen-flash-next |
|---|---|---|
| OSWorld-Verified | 84.3 | no published figure |
| WebArena-Verified | 64.8 | no published figure |
| AndroidWorld | 81.9 | no published figure |
27B scores: Qwen3.8-27B model card. Flash-Next scores: vendor-reported, agentic harness. Checked 2026-11. Neither is a measurement of this endpoint.
Those are the 27B's published vision and computer-use evaluations: desktop control, web navigation, mobile task completion. They are good numbers and there is no counterpart row from this build, so this is not a comparison — it is a column of the 27B's evidence with a blank next to it.
RawInfer does not publish vision evals for this build. The endpoint accepts image and video input; frames are encoded into the prompt like any other content. We make no score claim about how it performs on GUI agents, and any page that put a number here would be inventing one.
If a published vision benchmark is a procurement requirement — a contract that needs a citable OSWorld figure, an evaluation team that will not accept an absence — the 27B card has three such numbers and this page has zero. That is a legitimate reason to pick the 27B, and it is listed as one below.
320 prompts, zero hard refusals.
HarmBench-320 on this build: three effort settings, every topic, one endpoint. The 27B's card reports no refusal benchmark at all.
off and low. The category this build exists for.A benchmark table tells you what a model can do when it chooses to participate. It does not tell you how often it declines the request at the door. For some workloads that is the whole question — red teaming, detection engineering, trust-and-safety evaluation — and no coding score answers it.
The 27B card reports no refusal benchmark. That is an absence, not a result. We are not going to tell you what the 27B does on these 320 prompts, because nobody published that measurement, and a comparison page that guessed would be worth nothing on every other row too.
What can be said factually: the 27B is a general-purpose model with general-purpose post-training. This build is a cybersecurity build of the same generation with the refusal behaviour removed at the weight level, and the count above is what we measured afterwards.
Compliance also costs reasoning budget: at xhigh the model spends
more tokens before the first visible one. That is a latency trade you make per request, not a
policy the endpoint decides for you.
HarmBench-320 measured on this endpoint at three effort settings. Scores are not vendor claims and are not comparable to coding benchmarks above.
A flat month against a meter.
Same model class, two billing shapes. This is the part of the decision that changes with how long your runs are, not with how clever the model is.
One key, concurrency 5, fair use. Every request in a long agent run costs the same as the first one, because there is no per-token counter. A hundred requests is $5 and never expires — that is the trial, and there is no free tier.
We are not going to quote anyone's rate card; that belongs to whoever runs the endpoint this week. The shape is the point: input tokens and output tokens are counted, and in a 40-turn agent loop most of the input is history you re-send on every turn.
A metered bill grows with exactly the thing this comparison is about. The longer the run, the more turns, the more context per turn — a per-token meter compounds on all three. A flat month does not. That is not an argument that the 27B is expensive; it is an argument that the two prices answer different questions, and a benchmark page that ignored the difference would be optimising the wrong variable.
The flat plan has its own honesty clause: fair use, no resale, no key sharing, concurrency 5. It is not unlimited compute, it is unlimited requests under those terms. If your workload is a hundred thousand short classification calls, a meter may well be cheaper, and you should model it rather than take a vendor's word for either shape.
Both plans are crypto only. No refunds, either plan, at any time.
Two lists. One of them argues for the other model.
This page has a product to sell. Read the left list as an actual recommendation, not a straw man.
Pick the 27B if…
- You need published vision or computer-use evals — OSWorld-Verified, WebArena-Verified, AndroidWorld — because a procurement, audit or evaluation team requires a citable number.
- You want a general assistant: broad conversation, summarisation, translation, ordinary coding help, no adversarial workload anywhere in the product.
- You want to self-host the weights, control the hardware, and run inference inside your own perimeter.
- You want vendor support, an enterprise contract, and someone to call when the endpoint misbehaves — support that is not a one-person operation answering key and billing questions.
- Your runs are short and single-turn, where the 16.5-point gap on a long-horizon suite never gets a chance to matter.
Pick this if…
- Refusals are the problem, not the answer. 0 hard refusals across 320 prompts at every effort setting, 52/52 on cybercrime and intrusion at
offandlow. - Your agent runs are long and messy — multi-file refactors, incident reconstruction, test-suite archaeology — and the run has to close rather than report progress.
- You want the bill flat: $50 a month on one key, no per-token counter to defend in a review, no per-turn cost growth as a conversation fills up.
- You want zero data retention and no account identity beyond a key you generate and a payment you make in crypto.
- You are building detection, red-team tooling, or trust-and-safety evaluation where the model has to cooperate with the request in front of it.
If neither list describes you, the honest answer is that the benchmarks on this page are not going to settle it. Both models are Qwen3.8, both have 262,144 tokens of native context, both take images and video. Run your own twenty prompts against whichever endpoint you can reach cheapest and decide from that — it will be a better measurement than anything a model card publishes.
Take the key.
Try it for $5. If the sixteen and a half points are the reason you are here, that is enough to test them on your own repository.
Crypto only. No refunds. No logs. You are the operator.