One Qwen, four clients: Qwen Code, Codex, Claude Code, OpenCode

We ran the same local Qwen3.8-27B through Qwen Code, Codex, Claude Code and OpenCode on a home PC with an RTX 3090. The client materially changed the result. On a long Go repair, Qwen Code finished in 8:22 and passed independent acceptance. Codex took 19:10 and left a defect in its supposedly deterministic fallback. Claude Code produced a correct alternative in 28:52. On a smaller CSV import, however, OpenCode delivered the fastest fully correct patch.

This compares harnesses, the programs that turn a model into a coding agent. The underlying model did not change. It is not a comparison between local Qwen and hosted OpenAI or Anthropic models.

Here Qwen Code means the official terminal client. We did not evaluate a separate model called “Qwen Coder”. Each cell was one natural run on home hardware, so the evidence can guide another test but cannot establish reliability rates.

One task produced three different implementations

The long cell used a realistic problem in a larger Go repository. Its prompt identified two places that discarded json.Marshal errors and required:

• no change to successful response and text shapes;
• a safe, deterministic fallback;
• regression coverage for valid and unencodable values;
• focused tests, a build and the repository guard;
• updates to the relevant existing documentation;
• no unrelated guard cleanup.

Each client received the same prompt and commit in a separate worktree. All used Qwen3.8-27B on the same patched vLLM server, a 150k context window and medium effort.

OpenCode is absent from this table because no long-repair run exists. It appears below only in the three tasks that we actually ran.

What Qwen Code changed

Qwen Code reused the repository's existing helper for activity metadata. When JSON encoding failed, the helper returned an empty value and the outer field, marked omitempty, disappeared from the response. For webhook prompt text, it added a fixed (unavailable) marker.

That choice preserved the existing shape for ordinary values while preventing partial JSON or run-dependent output after an encoding failure. The agent added regression coverage for both consumers, updated three relevant documents and distinguished new results from failures reproduced on the pristine commit. Independent review found no defect inside the requested scope.

Why the Codex patch was rejected

Codex tried to preserve every metadata key by formatting unencodable values through Go's %v representation. This appears harmless for scalars. A non-nil channel or pointer, however, renders as a memory address such as 0xc00001c1c0, which changes between processes.

Its tests covered simpler values and a nil channel, so they passed. The documentation then repeated the false claim that the fallback was deterministic. A property-focused independent check exposed the contradiction.

The project built and much of the patch was sensible. We still rejected it because the implementation broke a requirement that its own report claimed to satisfy.

Claude Code chose consumer-specific fallbacks

Claude Code, still driving local Qwen, returned an empty JSON object to the metadata consumer and used the existing (not available) marker for webhook text. It added six tests and updated four relevant documents.

The implementation passed acceptance. Its wall time on one RTX 3090 was the problem: 28:52 versus 8:22 for Qwen Code. It also made repeated path and regular-expression escaping mistakes while running verification.

There is a more important support boundary. Anthropic does not support routing Claude Code to non-Claude models. Our result tests one endpoint emulator against one client release. It is not a configuration we would offer as a company standard.

OpenCode appears in the smaller jobs

OpenCode has no long JSON-repair cell. It does have three comparable results from the daily-driver suite. Every client received a normal issue-style request in a fresh copy of a small project.

The first prompt was:

Customers with several tags are showing up more than once in our CSV order export. Can you fix it? The export code is under src. Please keep the existing columns and add a regression test.

The README also defined a separator contract that the prompt did not repeat. Hidden checks established whether the agent had read it.

Public test totals varied because clients could add their own cases. The hidden checks were shared and are the comparable column.

OpenCode missed an explicit README contract in the small export, then won the import on both correctness and time. Qwen Code produced the best pagination scope but accepted an empty name or role in the import. Codex was slowest there and covered every hidden import case.

No client won every behaviour.

How a harness changes the same model

The client controls the instructions, tool descriptions, error recovery, context compaction and initial prompt footprint. Those differences were visible:

• Qwen Code understood Qwen-specific controls and used the long context most effectively;
• Codex oriented itself well on some small tasks but sometimes widened scope;
• OpenCode could be minimal and quick, then continue working after the solution was complete;
• Claude Code completed the emulated route, but that route lacks vendor support.

A team therefore does not deploy a “coding model” in isolation. It chooses a client, profile, permissions and repository-specific acceptance test.

What we selected

For this home setup, Qwen Code at medium effort remained the default for long work. OpenCode earned further testing on small, tightly bounded changes. Codex remained a useful control and supports configurable model providers on its side, but its local profile still needs its own evaluations. Claude Code with Qwen remains a compatibility experiment.

Another repository may reverse that order. Three internal tickets reveal more than a public leaderboard: one small bug, one feature with a hidden boundary and one change that needs a long history.

Turning the comparison into useful team practice

Syntalith can run this selection process on a client's repository. We take three to a dozen representative tasks, define shared acceptance and hidden checks, run two sensible profiles in isolated copies, and return:

• an accepted client and model profile;
• the concrete results, rejected options and reasons;
• tool boundaries and required approvals;
• a script that repeats the checks after upgrades;
• a workshop in which the team reviews the next change itself.

This can form part of an AI-Native Course on the team's own codebase. If the decision leads to a local deployment, an AI process audit fixes the architecture and scope. The free process scan first establishes whether local Qwen is worth evaluating or whether the existing tool should remain.

The complete sanitized figures are in the benchmark ledger. We separately show the frontend Qwen Code produced in 26 minutes.