Qwen Code is a client choice; DeepSeek is a routing decision

Keep Qwen Code authentication and DeepSeek service routing separate, with protocol-specific settings and a reviewable first task.

Selecting a coding agent and selecting an inference provider are related decisions, but they are not the same decision. Qwen Code supplies an interactive development workflow. DeepSeek supplies model services with documented API interfaces. A team can evaluate them together without pretending that every client, account and compatible endpoint shares the same capabilities or commercial terms.

The practical approach is to make each boundary explicit: which executable reads the repository, which provider receives the request, which credential pays for it, and which tools the agent may run. This article describes a proposed onboarding exercise with fictional code and no executed provider calls. Documentation was checked on 16 October 2026.

Verify the Qwen Code package first

The canonical project is `QwenLM/qwen-code`. Its README documents standalone installation and an npm path requiring Node.js 22 or later. For a reader choosing npm, the documented command is `npm install -g @qwen-code/qwen-code@latest`; after an approved installation, record `qwen --version` in a fresh terminal. [The official repository](https://github.com/QwenLM/qwen-code) is the reference for the package identity and prerequisites.

Do not mechanically treat GitHub's latest-release redirect as the CLI version. During this check it resolved to an SDK TypeScript release tag, which is a different deliverable. That is a useful example of why the executable's own version matters. A desktop wrapper detecting a `qwen` command on PATH establishes another fact again: detection does not prove that its provider or credentials are correct.

Use the current authentication menu

Qwen Code's current authentication documentation describes Alibaba ModelStudio, built-in third-party providers and a custom-provider route. DeepSeek appears among the documented third-party choices. The same page now describes the older Qwen OAuth free-tier route as discontinued, so tutorials built around that route are not a sound basis for a new account plan. [Authentication documentation](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/) is more useful than a remembered screenshot.

Start Qwen Code in an approved repository copy and open `/auth`. Select the route that corresponds to the account you actually possess. For a built-in DeepSeek choice, use the credentials and model choices documented for that integration. For a custom provider, obtain its protocol, endpoint and identifier explicitly. Use `/model` to inspect the available selection and `/doctor` for the client's supported diagnostics. A model list is not proof that the account can complete inference.

Keep configuration protocols explicit

Qwen's `modelProviders` system supports multiple protocol families. Its OpenAI-compatible path defaults to Chat Completions, while the current provider documentation describes a model-level `wireApi` choice for Responses. Anthropic and Google routes are separately identified. Therefore the statement “the client supports custom providers” is incomplete until the selected protocol and model entry are known. [Model Providers](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/model-providers/) describes those fields.

For a team setup, collect the provider ID, exact model identifier, protocol, base URL and the environment variable name used for its credential. Prefer a named environment source over embedding the key in a shareable settings example. Check the exact schema for the installed client before copying a configuration block: a field that belongs to one protocol does not automatically configure another.

This is also why a shared “AI key” is poor documentation. Keys identify accounts and services; they are not a universal capability token. The key that works for one provider may have no relationship to another provider's plan, quota or data policy.

DeepSeek also documents a different client path

DeepSeek's official Claude Code integration uses an Anthropic-compatible endpoint at `https://api.deepseek.com/anthropic`. That is a provider-documented route for Claude Code, not a claim that Qwen Code and Claude Code are interchangeable programs. Its companion [Anthropic API compatibility guide](https://api-docs.deepseek.com/guides/anthropic_api/) documents the compatibility surface; the [client integration page](https://api-docs.deepseek.com/quick_start/agent_integrations/claude_code/) supplies the current environment mapping.

If you evaluate that second route, label it separately in your notes. Record the actual `claude` version, selected DeepSeek alias and credential owner, and preserve its configuration independently from Qwen's. Do not copy all current model aliases or tuning variables into a permanent team template without understanding why each is required. A change in provider routing is not an upgrade of the local coding client.

Read the compatibility table as well as the quick start. DeepSeek currently lists document content blocks as unsupported and several fields, including some cache-control metadata, as ignored. A small successful text request therefore does not establish document-upload or prompt-cache behavior. Keep the client workflow within the documented surface, and verify the model that the service actually routes to rather than trusting a familiar-looking alias in the interface.

An illustrative provider-choice exercise

Suppose a fictional engineering team maintains a Python command that turns a directory of text notes into an index. The first pilot uses Qwen Code with one approved provider. Ask the agent to identify how duplicate filenames are handled, without changing files. Verify its explanation against a small fixture directory containing only invented notes.

Authorize a test covering two equal basenames in different folders. Require the agent to use the project's current test framework and confine its first patch to the test. Review the diff and the requested command before execution. Save the observed test outcome and any unresolved ambiguity about the intended behavior.

If the team later evaluates the documented DeepSeek-through-Claude-Code route, use another owned repository copy and the same task description. The comparison is not a benchmark ranking: the clients differ, and a small task cannot isolate every variable. Its purpose is to reveal operational differences such as model selection, permission requests, tool visibility and recovery after interruption. Keep those observations separate from the underlying model's public benchmark claims.

Separate free software from service access

An open-source client can still send requests to a commercial hosted API. Likewise, downloadable model weights carry their own license and hardware requirements; they are not a credit balance for a hosted service. Nothing about a successful Qwen installation proves that an arbitrary model is free to run, locally available or approved for sensitive source code.

Review the selected provider's current official terms and pricing page without freezing monetary figures into an onboarding document. Record who owns the credential and how it can be revoked. When local inference is proposed, identify the actual model artifact, serving process and machine limits rather than treating an OpenAI-compatible URL as proof of local execution.

Leave a route-specific handover

Finish with a connection table containing client executable/version, configuration source, protocol, endpoint, model identifier, credential owner, repository scope and the small task's observed outcome. Do not include the key. If a desktop application wraps the CLI, verify that external path independently after the terminal route works.

When something fails, diagnose the client, authentication, model access, protocol and repository behavior in that order. Avoid changing every layer at once. A useful provider choice is one a colleague can reproduce and recover safely, not one that happened to produce a fluent answer while its identity and tool boundaries remained unexplained.

Explanatory diagram and accessible reading guide


*Original explanatory infographic for “Qwen Code is a client choice; DeepSeek is a routing decision”. Documentation checked 16 October 2026. Fictional exercise; no connected account, completed request or observed result.*

[Open the full-size explanatory diagram](/assets/practical-ai-qwen-deepseek-routes-20261016.svg)

This original diagram explains documented boundaries and a fictional exercise that has not been run. It is not an authentic product screenshot, a connected account or a successful request.

Keep the client and protocol visible

Qwen Code and Claude Code have separate provider records.

Qwen Code

Inspect its own /auth, /model and diagnostic route.

Claude Code

Record its executable and configuration separately.

Chosen provider

Record exact endpoint, model, credential owner and protocol.

DeepSeek route

Documented Anthropic API route; check feature limits.

Repository copy A

Use invented notes and a bounded test-only task.

Repository copy B

Propose the same task with independent permissions.

Qwen OpenAI-family routing defaults to Chat; a model may choose Responses. DeepSeek compatibility has documented omissions.

Fictional Python notes indexer: two equal basenames in different folders. Proposed task, not a benchmark or executed call.

Solid arrows: documented route or stated task relationship. Dashed arrows: separately scoped permissions or proposed records. All paths are explanatory; no request or test ran.

Sources: Q_AUTH, Q_PROVIDERS, Q_REPO, D_CLAUDE, D_COMPAT. Full links and reading guide accompany this figure.

Qwen Code → Chosen provider: Qwen selects its own provider protocol; OpenAI-family Chat Completions and model-level Responses are distinct.

Claude Code → DeepSeek route: The provider documents a separate Claude Code route using its Anthropic-compatible endpoint.

Qwen Code → Repository copy A: Repository tools remain authorized through Qwen, not through the provider.

Claude Code → Repository copy B: Repository tools remain authorized through Claude Code, not through the provider.

Solid arrows describe inference configuration. Dashed side routes describe client-controlled workspace tools. They do not pass through the provider boxes. DeepSeek documents https://api.deepseek.com/anthropic for its Claude Code integration; document blocks and cache-related fields have compatibility limits. This figure does not establish an arbitrary Responses endpoint or feature parity for DeepSeek, and it does not reuse the discontinued Qwen OAuth free tier.

Read the duplicate-filename behavior first, then authorize a test in the existing framework. Use another owned copy if evaluating the later Claude Code route. Record client/tool/recovery differences without claiming the small task isolates model quality.

Diagram source references

- [Q_AUTH: Qwen Code authentication](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/) — QwenLM / Qwen Code.

- [Q_PROVIDERS: Qwen Code model providers](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/model-providers/) — QwenLM / Qwen Code.

- [Q_REPO: Qwen Code canonical repository](https://github.com/QwenLM/qwen-code) — QwenLM repository.

- [D_CLAUDE: DeepSeek integration with Claude Code](https://api-docs.deepseek.com/quick_start/agent_integrations/claude_code/) — DeepSeek.

- [D_COMPAT: DeepSeek Anthropic API compatibility](https://api-docs.deepseek.com/guides/anthropic_api/) — DeepSeek.