Qwen3.8-27B on a home RTX 3090: results, prompts and failures

After hours, we ran Qwen3.8-27B as a local coding agent on a home PC with one RTX 3090 and 24 GB of VRAM. In the main run, Qwen Code repaired two Go paths that ignored json.Marshal errors, added regression tests and updated the relevant documentation. It finished in 502.14 seconds, made 52 tool calls, generated 28,916 output tokens, used about 33.88 Wh and peaked at 22,539 MiB of VRAM.

After the run, Codex scored the patch 100/100 against our written criteria. An external auditor or independent laboratory did not assign this score.

That is a useful result for one person. It is not a general model ranking or evidence for an office-wide service. The server had one inference slot, and each long coding configuration was run once. The failures belong in the result too.

Download the data: all-run summary, full metrics for the 150k Qwen Code run, and long-context fact-retrieval results.

What we tested

The model is Qwen3.8-27B, a dense 27B model with a native 262,144-token context and a reasoning mode. The consumer GPU is an NVIDIA GeForce RTX 3090 with 24 GB of GDDR6X.

The experiment used two main serving paths:

• llama.cpp with Unsloth Dynamic V3 GGUF weights;
• a frozen third-party patched vLLM image with W4A16 AutoRound weights, FP8 KV cache and MTP-3.

The second path is not vanilla upstream vLLM. The measured result belongs to the complete profile: weights, server, cache, speculation, context setting and coding harness. It cannot be assigned to one component in isolation.

The three measurements behind the decision

For the long-context check, we placed one fact near the beginning, one in the middle and one at the end of a synthetic record, then asked the model to return those facts as JSON. A 50,059-token prompt finished in 59.3 seconds. A 230,085-token prompt took 563.4 seconds. Generation fell from 49.24 to 28.05 tokens per second.

On the same Go task, Codex scored Qwen Code with the 120k llama.cpp configuration at 98/100 after 1,468.76 seconds. The patched vLLM 150k configuration received 100/100 after 502.14 seconds. The second run used 65.8% less elapsed time and 66.2% less energy. This comparison covers complete configurations and does not isolate the weight formats.

What 100/100 means

Codex reviewed the patch after Qwen Code finished. The score was 40/40 for correctness, 20/20 for regression tests, 15/15 for compatibility, 10/10 for scope, 10/10 for verification and 5/5 for documentation. The focused tests, go build ./... and a diff-format check passed. The score only means that Codex found no deduction under this rubric in this run. It does not mean that Qwen is 100% reliable.

Natural-task run log

The frontend then needed 14:24 for the main repair and 7:58 for the visual follow-up. Total model time to the accepted variant was 48:25. The frontend case study contains the exact prompt, generated files, six repair defects and screenshots.

The full Go request did not prescribe the patch. It identified two ignored json.Marshal errors, required stable fallback behaviour, tests and documentation, and excluded unrelated cleanup. That made behaviour, tests and diff scope reviewable.

The most useful result began as a failure

The first one-shot frontend looked ambitious: search, recruitment stages, sorting, drawers and motion. Browser QA found that its virtualized ledger rendered every one of the 8,652 matching rows, creating 251,327 DOM elements and a document 485,065 pixels tall.

Qwen Code at medium effort repaired a copy. An independent desktop check then measured 722 DOM nodes, 15 rendered rows, a 900-pixel document and no horizontal overflow. Mobile had 577 nodes and 10 rows. Screenshot review still caught a name/company collision and a clipped stage marker. A follow-up fixed two CSS rules, and an independent recheck passed.

This run is more useful than a flawless showcase image. It separates code that appears finished from work that survives tests, browser geometry measurements and a second human review.

What the harness table does not compare

We also drove the same local model and server with the Codex harness and, experimentally, Claude Code. Codex the evaluator awarded 100/100 to the Qwen Code run, 87/100 to the run produced through the Codex harness, and 98/100 to the Claude Code run. In all three runs, local Qwen3.8-27B generated the code. These results compare harnesses around the same model. They do not compare Qwen with hosted OpenAI or Anthropic models.

Codex used a custom provider over the Responses protocol. Claude Code connected through a compatible Messages endpoint, but Anthropic does not support routing Claude Code to non-Claude models. The completed run demonstrates compatibility of the patched server used for this home experiment. It is not a supported Anthropic deployment pattern.

Is one RTX 3090 enough for a company

It can be enough for a controlled pilot, one engineer or a queue that may run sequentially. It cannot establish that ten people will receive simultaneous responses within an agreed service level. The host used for the experiment had one inference slot and deliberately disabled agent fan-out.

Before a team deployment, we measure:

1. peak requests per hour;
2. prompt and response length;
3. queue time;
4. human correction cost per result;
5. restart, failure and model-upgrade behaviour.

If the need is private source-code work for one user, a used consumer GPU may be rational. If the process requires concurrent answers and a hard SLA, it needs a throughput test and probably a different infrastructure class or an API.

What a company can buy from this work

Syntalith does not sell “Qwen on a server” as a box. We first choose several real tasks from the client's process and write down what a correct result must do. We compare the local model with a sensible alternative, then choose weights, serving, permissions, monitoring and the update process.

A deployment can include:

• a private endpoint and access control;
• repository or company-document integration;
• quality and latency tests;
• bounded tools and approval for risky actions;
• monitoring, rollback, documentation and team training.

Syntalith can deliver the system through custom AI applications. When the local-model case is still unclear, the first step is a free process scan: 30 minutes with an engineer and a written conclusion within two business days. “Keep the API” is an acceptable conclusion.

Where the numbers come from

We collected the measurements from 18 to 21 August 2026. The public JSON files include time, energy, VRAM, token and tool-use metrics, plus the three long-context outputs. The private source directory also retains event logs, GPU samples, diffs, tests and final agent messages.

Each configuration was run once. The numbers describe those runs and do not estimate the probability that the model will repeat them. Codex assigned the 100/100, 98/100 and 87/100 scores under Syntalith's criteria. No human auditor or independent laboratory assigned those scores.