RTX 4070 Ti SUPER 16GBで「Qwen3.8-27B」を動かす ― コンテキスト16Kでは失敗、32KでWebアプリ生成に成功A hands-on report running Qwen3.8-27B locally on an RTX 4070 Ti SUPER 16 GB GPU…

A recent hands-on report published on Qiita examines a practical question that many enthusiasts ask before committing to local large language models: how far can a consumer-grade desktop actually take you? The author ran Qwen3.8-27B on an Ubuntu PC equipped with a single RTX 4070 Ti SUPER with 16 GB of VRAM, and rather than simply testing whether the model could hold a conversation, they used it as a coding agent through OpenCode to generate a web application. The most notable finding is that the same task failed at a 16K context window but completed successfully at 32K, offering concrete guidance for anyone assembling a local setup on similar hardware.

The distinction matters because context length, the amount of text a model can consider at once, is often overlooked when people focus on raw parameter counts. For agentic coding workflows, the context has to hold not just the user's request but also system prompts, tool definitions, file contents, intermediate reasoning, and the growing history of the agent's own actions. When that budget is too small, the agent can lose track of earlier steps, drop important instructions, or terminate before finishing. The report's result suggests that for this particular web-app generation task, 16K tokens was insufficient headroom for the agent to carry the job through to completion, while doubling it to 32K allowed the process to run to the end.

Running a 27B-class model on a 16 GB card is itself a balancing act, and the outcome likely depends heavily on quantization and offloading. A model of that size in full precision would far exceed 16 GB, so local deployment typically relies on quantized weights, commonly in 4-bit or similar formats, to fit within available memory. Even then, a larger context window consumes additional memory for the key-value cache, which grows with sequence length. This creates a trade-off familiar to local LLM users: a bigger context improves an agent's ability to complete complex tasks, but it also increases memory pressure and can slow generation, especially if part of the model or cache spills over to system RAM or the CPU.

The tooling described in the report reflects a maturing local ecosystem. Ollama, referenced in the article's tags, is a widely used runtime that simplifies downloading, quantizing, and serving open-weight models through a local API, lowering the barrier for people who do not want to manage inference backends by hand. OpenCode belongs to a growing category of terminal-based and editor-integrated coding agents that can plan, write, and edit code, and it can be pointed at a local model instead of a commercial cloud API. This combination, an open-weight model served locally and driven by an agent framework, is what allows a home machine to attempt tasks that until recently were associated primarily with hosted services.

Qwen, the model family used here, is developed by Alibaba and has become one of the more prominent open-weight lineages, with variants tuned for general chat, coding, and reasoning. The broader competitive landscape includes other open families such as Meta's Llama, Mistral's releases, and Google's Gemma, all of which are frequently benchmarked by the local-LLM community for exactly this kind of workload. The appeal of these models on personal hardware is straightforward: privacy, offline availability, no per-token billing, and full control over configuration, in exchange for the effort of tuning settings like context length, quantization level, and layer offloading.

For readers considering a similar build, the report's practical takeaway appears to be that context length is a tunable parameter worth testing deliberately rather than leaving at a default. A setup that seems to fail may not indicate that the model is incapable, but rather that the context window was too constrained for an agentic task with heavy overhead. It is worth noting that a single case study on one task and one hardware configuration does not generalize to every workload, and results are likely to vary with different prompts, agents, and quantization choices. Still, the experiment provides a useful data point: with careful configuration, a 16 GB consumer GPU can drive a 27B model through a real, multi-step coding task, provided the context budget is large enough to see it through.