Qwen3.8-27B: benchmarks, speed and how to use it without a GPU

What Qwen3.8-27B is

Qwen3.8-27B is a 27-billion-parameter dense model in Alibaba's Qwen family, released in August 2026 under the Apache 2.0 license with open weights on Hugging Face. It has a native context window of 262,144 tokens (256K), which is enough for a mid-size repository or a long multi-turn coding session without needing to truncate history.

Because the weights are open, you can run it yourself if you have the hardware and the patience to manage an inference stack, or you can reach it through a hosted API and skip both. That's the route this page is mostly about: what the model actually scores on, how fast it runs in practice, and how to call it without buying anything.

Benchmarks: where it lands next to a frontier model

For a model this size, the numbers matter more than the framing. The scores below come from Qwen's own model card (checked 2026-09-17), compared against Opus 4.6 Max as a frontier reference. The agentic runs used the Claude Code harness on both sides. These are full-precision, model-card numbers, and the 4/5-bit quantized build that NeverMetered actually serves can score a little lower on any of them.

The SWE-bench Pro row needs a footnote before you read too much into it. Opus's 53.4 is Anthropic's own officially reported figure, while Qwen re-ran the other three benchmarks on a corrected setup. That makes this particular pairing less apples-to-apples than the rest of the table, so treat it as a data point rather than a conclusion.

Taken together, the pattern is roughly what you'd expect from an open 27B model: competitive on terminal work and contest-style code generation, behind on the benchmarks that reward broader reasoning and repository-scale planning. It's strong for its size class, not a frontier replacement, and there's no reason to dress that up. NeverMetered doesn't publish live evaluations against full precision yet, that work is in progress, and we'd rather say so than guess at a number.

Measured speed

These figures are from NeverMetered's own dual-GPU servers, measured in September 2026, not a vendor claim copied from a spec sheet.

• First token: well under 1 second on a short prompt, up to roughly 2.5 seconds when a server is at full load.
• Generation speed: about 42 tokens/second on a single stream, dropping to roughly 29-31 tokens/second per stream when all 8 concurrent requests on a server are busy at once.
• Prompt reading: about 700-950 tokens/second. A 19,000-token prompt takes around 20 seconds to process on its first turn.
• Follow-up turns in the same conversation reuse the cache and skip most of that reading time.

For reference, OpenRouter's public data put Claude Opus on Anthropic's own infrastructure at about 61 tokens/second as of September 2026. Qwen3.8-27B on a single stream runs a bit behind that, and it runs slower still once a server is handling multiple requests at once. If you're running one task at a time, the difference is a few seconds per response. If you're fanning out several agents, how many parallel streams you have matters more than the per-stream number.

Getting API access without buying a GPU

You don't need to rent hardware or run your own inference stack to use Qwen3.8-27B. NeverMetered hosts it and serves it over the OpenAI Chat Completions and Responses APIs, plus Anthropic Messages, all on one base URL, so plugging it into an existing setup is usually a base-URL and API-key change rather than a new integration to write.

The model is served through NInfer, an open-source inference engine built by Neroued (NeverMetered runs it, it didn't build it). The specific weights are a NInfer-format build, a file called qwen3_8_27b.ninfer at about 19.0 GB, quantized to 4/5-bit with a 4-bit (rk4v4) KV cache, with its repository, revision and checksum published on /how-it-runs for anyone who wants to check the details themselves.

Pricing here isn't per-token. NeverMetered sells parallel streams, meaning how many requests can generate at the same time on your plan. There's no meter counting your tokens, no 5-hour window, and no weekly cap that resets and locks you out. A request that arrives when every stream on your plan is busy doesn't fail, it waits briefly in a fair queue and runs as soon as a slot frees up. The diagram below shows the shape of it: requests come in, a queue smooths out bursts, and a server works through however many concurrent streams your plan includes.

Setup is meant to be boring in the good way. NeverMetered has guides for all 19 supported tools at Integrations, including Claude Code, Codex CLI, Copilot CLI, Cursor, Cline, Aider, OpenCode, Hermes Agent, OpenClaw, DeepSeek Harness, Pi, Oh My Pi, Continue, the OpenAI SDK, the Anthropic SDK, the Vercel AI SDK, LangChain, LiteLLM, and plain curl. If your tool already speaks OpenAI or Anthropic's API shape, it can point at Qwen3.8-27B in a few minutes.

Plans, pricing and data handling

NeverMetered doesn't publish a price on this page because plans change, so check current plans for the real numbers. What's fixed is the shape of the deal: once you subscribe, your plan's price and stream count are locked for 12 months, and any change after that comes with 30 days' notice by email. Paid plans never get a token quota, a 5-hour window, or a weekly cap added on top, no matter how the plan itself changes.

There's also a free tier, a small daily request allowance that requires a verified email. The exact allowance isn't listed here since it's plan data that can move, so current plans is the source of truth if you want the real figure before signing up.

On data handling: prompts and completions are processed in memory only. They're never written to a database or to logs, and no third-party AI provider ever sees them, because NeverMetered runs the model on its own servers rather than routing requests anywhere else. Nothing you send is used to train models. What is kept is request metadata, things like token counts, timings, and status, and that's only there to power your usage dashboard.

Where this fits in your workflow

The honest pitch for Qwen3.8-27B on NeverMetered isn't that it replaces a frontier model. It's a second lane. Keep your Claude or Codex plan for the hardest problems, the ones where you actually want the frontier reasoning, and send the rest, test runs, refactors, docs, long agent loops that chew through tokens, somewhere that doesn't run out partway through the afternoon.

That matters more than it sounds like once you've hit a limit mid-task. If you've run into Claude usage limits, the Claude Code pricing tiers, Codex usage limits, or Cursor usage limits in the middle of a long session, the appeal of a flat-rate lane is fairly self-explanatory. If you'd rather run something on your own hardware instead of a hosted API, the best local LLM for coding guide covers that path, and if you want to see how Qwen3.8-27B stacks up against other options at a glance, the comparison hub has the rest of the field.