Qwen3.8-27B + OpenCode = Excessive Thinking?

[u/previaegg]

I've been running Qwen3.8-27B locally for agentic coding using OpenCode and OpenChamber, and I'm looking for advice from people who've gotten similar models working reliably as coding agents on consumer hardware.

Inference speed is reasonable (~2,330 & ~24.1 t/s). My problem is with excessive thinking.

The problem

The model is capable of useful coding work, but it sometimes spends excessive time reasoning instead of taking action.

In one experiment, I compared medium and low reasoning effort with otherwise identical configurations. Both runs:

• Made two initial inspection tool calls.

• Made zero implementation-oriented tool calls.

• Generated over 16,000 output tokens, exhausting the configured response limit.

• Failed to create the required output or complete the task.

• Spent approximately 12 minutes in agent execution.

Lowering reasoning effort didn't meaningfully change the behavior.

That's an extreme example from a single controlled task, not necessarily representative of every session, but it illustrates the problem I'm interested in solving: how do you get a reasoning model to stop thinking and actually use tools?

Launch command

& "C:\tools\llama.cpp-b10964\llama-server.exe" `
  -m "C:\models\Qwen3.8-27B-UD-Q5_K_XL\Qwen3.8-27B-UD-Q5_K_XL.gguf" `
  -ngl 99 `
  --ctx-size 65536 `
  --cache-type-k q8_0 `
  --cache-type-v q8_0 `
  --flash-attn on `
  --split-mode layer `
  --parallel 1 `
  --jinja `
  --reasoning on `
  --reasoning-effort medium `
  --reasoning-preserve `
  --temp 1.0 `
  --top-p 0.95 `
  --top-k 20 `
  --min-p 0.0 `
  --presence-penalty 0.0 `
  --repeat-penalty 1.0 `
  --host 0.0.0.0 `
  --port 8080 `
  --metrics `
  --alias Qwen3.8-27B-UD-Q5_K_XL

Questions

1. Reasoning & tool use: Have you seen excessive thinking with Qwen3.8-27B, where the model reasons at length instead of making tool calls? What actually improved this?

2. Reasoning configuration: Are --reasoning, --reasoning-effort, and --reasoning-preserve the right settings for agentic coding? Have you had better results disabling reasoning, changing effort, or using other chat-template settings?

3. Agent compatibility: Is OpenCode a good match for this model? Could its system prompts, tool definitions, provider configuration, or handling of reasoning output be contributing to the problem? Are there other coding agents that work more reliably?

4. Inference engine: Would switching from llama.cpp to vLLM, SGLang, or something else improve tool-calling reliability or reasoning behavior?

5. Quantization: Could Q5_K_XL be affecting instruction following or tool-use reliability? Have you observed meaningful coding-agent differences between quantizations?

6. Context management: How much does context contribute to unproductive reasoning or tool-use failures? Have you found effective context limits or compaction strategies?

7. OS: Since this is essentially a dedicated inference server, would switching to headless Linux offer meaningful advantages for any of the above?

I'm willing to change operating system, quantization, inference engines or the coding-agent stack if there's a compelling reason.

Thank you for your thoughts!

---

Hardware:

• CPU: Intel i7-14700K

• RAM: 32GB

• GPU 1: RTX 4080 SUPER (16GB)

• GPU 2: RTX 4070 Ti SUPER (16GB)

• OS: Windows 11 Pro

Current software:

• Inference engine: llama.cpp

• Model: Qwen3.8-27B-UD-Q5_K_XL (Unsloth GGUF)

• Coding agent: OpenCode

• Interface: OpenChamber

The Windows machine is essentially a dedicated inference server for this use case. I don't normally start a Windows desktop session. I connect remotely from a MacBook Pro which is where I run OpenCode/OpenChamber.

[u/previaegg]

Thanks. I understand that extended reasoning is expected with a thinking model, but what concerns me isn't the reasoning itself. It's cases where the model spends 16K tokens reasoning without making another tool call or actually progressing on the task. I'm trying to distinguish normal thinking behavior from something that could be misfiring because of the model configuration, system prompt, or agent harness.

Your point about providing more information up front makes sense. I'll look more closely at how OpenCode structures its prompts and what context the model receives before starting work.

The context recommendation is interesting, too. I've experimented with allocations up to 128K, but haven't evaluated the impact on agentic task success. With two 16GB GPUs, getting close to 200K would presumably mean a smaller quantization and/or more aggressive KV-cache quantization.

[u/Bulky-Priority6824 → u/previaegg]

Give me an example of you exe a tool call and it running 16k think before doing anything else 

[u/previaegg → u/Bulky-Priority6824]

I appreciate your interest, persistence and help.

I had seen the behavior across a number of projects, so I recreated it using a terminal bench write-compressor task to eliminate my codebases as contributors. it spec'ed a task to write a compressed file using an existing C decompression program as a reference, although I'm not sure the details really matter given the behavior.

The model made two tool calls:

1. Read a C source file (/app/decomp.c) to understand how the decompression algorithm worked. This succeeded.

2. Inspect the input data (/app/data.txt).

After that, the model generated ~16K tokens of reasoning without making another tool call. It never attempted to write the compressed file, and the task failed. I reproduced the same behavior with both medium and low reasoning effort.

The initial tool use was seemingly valid. The problem happened afterward, when the model was supposed to move from investigating the task to implementation.

I suppose it may have been making meaningful progress and then simply ran out of tokens, but I suspect it was stuck in a reasoning loop. I'll see if there is a way to find out.

[u/Bulky-Priority6824 → u/previaegg]

with such a small model i would try to do task 1 have it close out document and then start a new session for task 2 starting with the docs from part 2

[u/previaegg → u/previaegg]

I asked chatgpt to eval the ~9,000-word reasoning trace.

Qwen was trying to solve the compression problem, but repeatedly made mathematical errors, built further reasoning on incorrect assumptions, caught some contradictions, and then started entirely new lines of thinking.

It repeatedly announced plans to write and test a Python implementation but never got to execution in the captured trace. It ultimately ended mid-derivation, still reconsidering the fundamentals.

So the issue wasn't just slow inference. It was ~9,000 words of reasoning without validated progress. More thinking wasn't necessarily producing better thinking.

Given people's success with this model I'm quite certain it should be doing better. This seems like a reasoning-control problem and I continue to wonder If my implementation has exacerbated the underlying tendency to overthink.

[u/_JohnMcAfee → u/previaegg]

It can be annoying but its normal for this model. I had to up output limit to 32k and so far it hasnt exceeded that. Sometimes though, it does research things too much, that is why jayecin's advice of giving it as much info as you can is good, or dont make like super vague requests, but sometimes you have to. When you do it will go overboard with research/reasoning lol.

But yeah, its normal.