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

We ran the same local Qwen3.8-27B model 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. Codex took 19:10 and left a defect in its intended deterministic fallback. Claude Code produced a correct alternative in 28:52. On a smaller CSV import, OpenCode delivered the fastest fully correct patch. Codex assigned the final scores to these recorded runs from their test results and the Syntalith criteria sheet.

This compares harnesses, the programs that turn a model into a coding agent. The model and its weights stayed the same. The comparison does not include hosted OpenAI or Anthropic models.

Here Qwen Code means the official terminal client. The name does not refer to a separate model called “Qwen Coder”. Each result came from one run on home hardware, so it can guide another test without establishing repeatability.

Times in this article are the elapsed time from launch to completion recorded in each run log. A k/n value in the CSV table is the number of shared hidden checks passed out of the total. A 100/100 value is a score under the Syntalith criteria sheet. The scale reports points for the run; percentages of correct answers appear separately in the test results. Codex evaluated the recorded runs made with Qwen: 40 points for correctness, 20 for regression tests, 15 for compatibility, 10 for scope discipline, 10 for verification and 5 for documentation.

One task produced three different implementations

The long run 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 frozen third-party patched vLLM stack, with an advertised 150,000-token context window and medium effort.

Each score is for this single recorded run under the same Syntalith criteria sheet. Codex assigned the points from the tests and checks recorded after Qwen's work; 100/100 means that the focused test suites, full build, Git change check and the remaining criteria passed. It says nothing about repeatability.

OpenCode is absent because there is no recorded long-repair run for it. It appears below in the three tasks 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. Codex evaluated the recorded run under the Syntalith criteria sheet and assigned 100/100 because both focused suites, the full build, the Git change check and the other criteria passed. This was a single-run evaluation performed by Codex; no external auditor took part.

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 rejected it because the implementation broke a requirement that its own report claimed to satisfy.

Claude Code chose consumer-specific fallbacks

Claude Code used 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 the checks and received 98/100 under the same Syntalith criteria sheet, assigned by Codex from the recorded run. Its elapsed time on one RTX 3090 was the practical problem: 28:52 versus 8:22 for Qwen Code. It also made repeated path and regular-expression escaping mistakes during verification.

There is an important support boundary. Anthropic does not support routing Claude Code to non-Claude models. Our result covers one endpoint emulator and one client release. We would not offer this route as a company standard.

OpenCode appears in the smaller jobs

OpenCode has no result for the long JSON repair. It does have three comparable results from the daily task set. Every harness received the same ordinary 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. Shared hidden checks established whether the agent accounted for that documentation.

Public test totals varied because clients could add their own cases. The hidden checks were shared and form the comparable column. The times are elapsed times from launch to completion for single runs, and medium means the client's medium reasoning setting.

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

No client was best on every task.

How a harness changes the same model

The client controls the instructions, tool descriptions, error recovery, history compaction and initial context 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 deploys a coding model together with 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, while 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 measured values are in the public results summary. We separately show the frontend Qwen Code produced in 26 minutes.