Yesterday morning my feed exploded with a model release again. But this one was different from the usual frontier drop. Qwen 3.8 27B hit the top of Hacker News and stayed there: at the time I checked, the thread had passed 1,194 points with 713 comments in under a day. That is the kind of heat normally reserved for a $5-per-million-token API announcement.
The twist is that this is a dense 27-billion-parameter open model, Apache 2.0 licensed, that people are running on laptops. Simon Willison ran it on an M5 Max MacBook Pro through LM Studio with a 17GB GGUF file and spent 21 minutes watching it think about an SVG (his comment). I build production AI systems with Spring Boot and Spring AI, so my first question was not "how smart is it?" It was: can I call this thing from the code I already have, without a second SDK or a cloud account?
The answer is yes, and the setup is smaller than the model's license file. Here is what shipped, what the community actually found when they ran it, and the exact Spring Boot wiring for a local Qwen 3.8 27B.
Qwen 3.8 is the latest generation of Alibaba's open model family, and 27B is its compact dense member. The model card lists the headline details:
xhigh
, medium
, and low
. It also keeps reasoning context from earlier messages (preserve_thinking
) for multi-step agent work.The model hit the ground running: 91,917 downloads and 9,465 likes on the base repo and 123,157 downloads on the FP8 repo within about a day of release. Apache 2.0 means you can use it, modify it, and ship it without asking permission.
On benchmarks, Qwen's own tables show big jumps over Qwen3.6-27B. These are vendor numbers, evaluated with the Claude Code harness at temperature 1.0 and a 256K context window, so treat them as directional:
Again: those are Qwen's own numbers. The community thread is where the model gets tested by people who do not care about vendor tables, and that is where the interesting stuff shows up.
The HN thread is unusually dense with hands-on reports, because a 27B open model is something most of the audience can actually pull and run the same day.
xhigh
reasoning mode the model "overthinks so badly that it writes terrible bushy code," and watched it cycle through "FINAL FINAL APPROACH" and "OK TRULY FINAL APPROACH" before finishing. In low
mode it behaved better (The pattern across all of these reports: the model is genuinely capable for its size, and the friction is operational. Thinking tokens, context budgets, and VRAM math. Those are exactly the problems a Spring Boot integration should be solving for you, and it turns out the integration is trivial.
Full disclosure up front: I wrote this the day the model dropped. I verified every API call below against the Spring AI reference docs and the Ollama library page, and I cross-checked the numbers against community run reports, but I have not yet pointed a production workload at this specific model. The wiring pattern is the same one I use daily with other local models through Ollama, and it is genuinely small.
The easiest path is Ollama. The library already lists qwen3.8
with tags for 27b
, 27b-q4_K_M
, 27b-q8_0
, 27b-bf16
, 27b-mxfp8
, 27b-nvfp4
, and MTP variants (library page). Pull the quantized version that fits your hardware:
ollama pull qwen3.8:27b-q4_K_M
Hardware reality check from the thread: a 4-bit quant lands around 17GB, which runs on a Mac with 32GB+ unified memory or a 24GB GPU. On 20GB cards you will be trading context length for speed, and a 5090-class card gets you over 100 tokens per second with the right engine. If you prefer LM Studio, its Qwen3.8 page hosts the GGUF with the same quant options.
This is the only dependency you need. Spring AI's Ollama starter speaks the OpenAI-compatible chat shape, so anything that runs behind Ollama is a drop-in:
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-ollama</artifactId>
</dependency>
application.properties
Two properties. The base URL is Ollama's default local port, and the model name matches the tag you pulled:
spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.chat.options.model=qwen3.8:27b-q4_K_M
spring.ai.ollama.chat.options.temperature=0.7
Spring AI gives you the same ChatClient
builder you already use for any other model. A minimal service:
@Service
public class QwenLocalService {
private final ChatClient chatClient;
public QwenLocalService(ChatClient.Builder builder) {
this.chatClient = builder.build();
}
public String ask(String question) {
return chatClient.prompt()
.system("You are a senior software engineer. Think briefly, then answer.")
.user(question)
.call()
.content();
}
}
The system prompt matters here. Because Qwen3.8 thinks by default and will happily burn 20,000 reasoning tokens on a two-sentence answer, a prompt that sets the expected depth is your first line of defense against the overthinking the thread keeps reporting.
Qwen3.8 is a vision-language model, and Spring AI's multimodal support covers it. The documented pattern is a UserMessage
with a Media
object attached. Per the Spring AI multimodal reference:
UserMessage message = UserMessage.builder()
.text("Describe this diagram and explain what the arrows mean.")
.media(new Media(MimeTypeUtils.IMAGE_PNG, new ClassPathResource("architecture.png")))
.build();
ChatResponse response = chatClient.prompt()
.messages(message)
.call()
.chatResponse();
This is the part that makes local Qwen interesting for Java teams: document parsing, screenshot analysis, and UI recreation on images that never leave your machine.
Qwen3.8 exposes reasoning_effort
(xhigh
, medium
, low
) and the ability to disable thinking entirely. On Ollama you can pass these through the options map, so low-latency paths can skip the long reasoning pass:
chatClient.prompt()
.system("Answer directly, no reasoning.")
.user(question)
.options(OllamaOptions.builder()
.model("qwen3.8:27b-q4_K_M")
.temperature(0.7)
.build())
.call()
.content();
The model card's own advice for non-thinking mode is temperature=0.7, top_p=0.80, presence_penalty=1.5
, which is a good starting point for direct-answer workloads.
The thread's operational lessons, turned into a checklist for anyone wiring a local model into a real service:
xhigh
by default.medium
, escalate per task.The honest takeaway: Qwen 3.8 27B is the first dense open model in a long time that makes me double-check my cloud API bill. For a Spring Boot team, the integration cost is one dependency and two properties, the model is Apache 2.0, the data never leaves your network, and the main engineering work is taming its thinking. That is a trade worth testing this weekend.
I write about Java, Spring Boot, and AI every week. Subscribe, it's free.
Have you run Qwen 3.8 27B (or any local model) in a real service? What did you have to tame first, speed or thinking? Tell me about it in the comments.