OpenCode Qwen3.7-Plus Provider Available: Non-Quantized Agent Support

OpenCode qwen3.7-plus provider available non quantized agent supports qwen3.7-plus: yes, Qwen3.7-Plus is available through QwenCloud’s hosted API and can be configured in OpenCode as an OpenAI-compatible provider. It supports function calling, so it can power an OpenCode coding agent, but it is not an official downloadable model whose weights you can run in a non-quantized format.

The important distinction is between a model being available to an agent and its weights being available to you. Qwen3.7-Plus is currently an API product: you select the upstream model ID, authenticate to QwenCloud, and let the provider operate the inference stack. That is useful for a large-context coding workflow, but it is not the same thing as self-hosting BF16 or FP16 weights.

Is Qwen3.7-Plus available in OpenCode?

Yes. OpenCode can use providers from its catalog, and it also supports explicitly configured providers. QwenCloud documents an OpenAI-compatible endpoint and uses qwen3.7-plus as the model name, which makes a custom OpenAI-compatible OpenCode provider the straightforward integration path. [1][2]

Before writing configuration, try OpenCode’s model picker. Connect the provider if it appears in your installed OpenCode version, then run /models and select the identifier OpenCode shows. That is safer than guessing an ID because provider catalogs and available regional endpoints can change. If the model is not listed, add the explicit provider configuration below.

How to configure the Qwen3.7-Plus provider in OpenCode

Create a QwenCloud API key and export it as DASHSCOPE_API_KEY. QwenCloud’s current compatible endpoint is https://dashscope-intl.aliyuncs.com/compatible-mode/v1, and its documentation shows that endpoint being used with the qwen3.7-plus model ID. Do not put the key directly in opencode.json or commit it to a repository. [2]

export DASHSCOPE_API_KEY="your-qwencloud-key"

Then add this to a project-level opencode.json or your global OpenCode configuration. The limits and capabilities describe the upstream model to OpenCode; they do not create those capabilities. QwenCloud documents a 1M-token context window, text/image/video input, text output, and function calling for this model. [3][4]

{
  "$schema": "https://opencode.ai/config.json",
  "model": "qwencloud/qwen3.7-plus",
  "providers": {
    "qwencloud": {
      "name": "QwenCloud",
      "env": ["DASHSCOPE_API_KEY"],
      "package": "@opencode-ai/ai/providers/openai-compatible",
      "settings": {
        "baseURL": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
      },
      "models": {
        "qwen3.7-plus": {
          "modelID": "qwen3.7-plus",
          "name": "Qwen3.7-Plus",
          "capabilities": {
            "tools": true,
            "input": ["text", "image", "video"],
            "output": ["text"]
          },
          "limit": {
            "context": 1000000,
            "output": 65536
          }
        }
      }
    }
  }
}

OpenCode’s current provider configuration supports a custom provider package, a base URL, environment-based credentials, explicit model IDs, declared limits, and tool capability metadata. It also warns that custom-model limits and capabilities must match what the upstream service actually supports—OpenCode cannot infer them for you. [1][5]

Does Qwen3.7-Plus support OpenCode agents and tool calls?

Yes, with one qualification: the model’s tool support and OpenCode’s agent loop are separate layers. QwenCloud advertises function calling for Qwen3.7-Plus, while OpenCode uses the selected model’s declared tools capability to decide whether agent tools can be made available. In practical terms, that means the model can receive tool definitions, request a file edit, shell command, search, or other tool action, and then continue after OpenCode returns the result. [3][4]

That does not guarantee that every task will be completed autonomously. Tool-use reliability depends on the model’s behavior, the provider’s protocol compatibility, the prompt, the repository, and the permissions you grant. Start with a small, observable task: ask the agent to inspect one module, propose a narrow change, edit it, and run the relevant test. Confirm that tool calls are emitted correctly before giving it a long refactor or production credentials.

Is Qwen3.7-Plus non-quantized?

No public deployment choice is described that way. “Non-quantized” normally means you have model weights in a higher-precision format—commonly BF16 or FP16—rather than a reduced-precision checkpoint such as 8-bit, 6-bit, or 4-bit. That question matters when you download and run a model yourself, because precision changes VRAM requirements, throughput, and sometimes quality.

Qwen3.7-Plus is presented by QwenCloud as a hosted API model. Its official pages document API invocation, model capabilities, context limits, rate limits, and token pricing; they do not offer an official checkpoint download or an inference-precision selector. So it is inaccurate to advertise it as “non-quantized,” but also inaccurate to call it a quantized local model. The serving precision is an implementation detail of the hosted provider rather than a knob OpenCode users control. [2][3]

What does Qwen3.7-Plus cost for coding-agent work?

As of August 6, 2026, QwenCloud lists qwen3.7-plus at $0.40 per million input tokens and $1.60 per million output tokens for requests up to 256K input tokens; its published rates increase for longer-context requests. Agent usage can consume more input than a normal chat because each turn may include system instructions, repository files, tool schemas, command output, and prior conversation. [6]

Treat the 1M context window as headroom, not a target. Large context can be valuable for broad repository understanding, but it can also increase latency and cost. Use focused tasks, keep generated logs out of context where possible, and start a fresh session after a task’s assumptions have changed substantially.

How to troubleshoot Qwen3.7-Plus in OpenCode

• Run /models after configuring the provider. If qwencloud/qwen3.7-plus is absent, verify that the configuration file is in an OpenCode location that is loaded for the current project.
• Check that DASHSCOPE_API_KEY is present in the shell that launched OpenCode. A key exported in one terminal session is not automatically available in every editor or service process.
• If requests return a model-not-found error, use the exact upstream modelID qwen3.7-plus and verify the QwenCloud endpoint and account access.
• If the agent only answers in prose instead of using tools, verify that tools is set to true and test a small task that explicitly requires a command or file read.
• If multimodal input fails, first test text-only coding work. Image and video support from the API does not guarantee that every OpenCode client path or installed version forwards each modality identically.

Use a coding agent with provider choice, not provider lock-in

If the practical question behind this setup is how to try Qwen3.7-Plus without tying your workflow to one model vendor, Cline is worth a look. It is an open-source AI coding agent that works in an editor and terminal, can read and write files, run commands, and use a browser—with explicit approval for actions. That makes it relevant when you want to evaluate a model on a real repository rather than judge it from a chat response alone.

Cline is free for individual developers, with no subscription or seat fee for the open-source version; you pay for inference usage, either through its provider or with your own API keys. Its documented bring-your-own-key approach and broad provider support give engineers room to test hosted models, compare cost and tool behavior, or move to local models when the model weights actually exist.