KDnuggets shows how to run Qwen3.5 on an old laptop with Ollama and OpenCode

On April 8, KDnuggets published a practical walkthrough on turning an old laptop into a local AI workstation, with no expensive hardware and no cloud subscriptions. The setup centers on Qwen3.5 in its 4B version, Ollama for running models locally, and OpenCode as a coding agent that works straight from the terminal.

Why bother?

The article's main point is that local AI tools no longer require a powerful workstation or a dedicated server. The author shows that even an aging laptop can serve as a private environment for experiments, coding and quick checks, provided you pick a compact open model and don't burden the stack with extra layers. In this scenario Qwen3.5 4B is presented as a reasonable compromise between answer quality, speed and hardware requirements.

This is not about replacing flagship cloud models. The setup serves a different purpose: giving developers, students and enthusiasts an inexpensive way to run AI locally, without sending files and prompts to external services, and to test ideas quickly on their own machine. For draft code, learning tasks, simple terminal workflows and small tests this is already enough, even if answer quality doesn't always match the best commercial systems.

How the setup works

The basic stack has two parts. Ollama downloads, stores and runs the language model on the local device, while OpenCode sits on top and turns it into a more practical agent interface for working with code.

The article uses the Qwen3.5:4B variant, which the author estimates typically needs about 3.5 GB of RAM. That makes it a realistic choice for an old laptop with no spare GPU or memory.

• install Ollama on Windows, Linux or macOS
• start the local Ollama server manually if needed
• download and open the Qwen3.5 4B model in the terminal
• install OpenCode with a quick script
• launch OpenCode with the local model already connected

Afterward the user gets a local interface where the model can be asked to create a project, install dependencies or check code. A further plus of the guide is that it keeps the barrier to entry low: no Docker orchestration, no manual API setup and no lengthy environment build. Compared with many local-AI articles, this looks like a genuinely practical scenario you can repeat in an evening, rather than an engineering project lasting several days.

Testing on a real task

To show not just installation but the real value of the approach, the author had the Qwen3.5 and OpenCode combination build a small Python project from scratch: a terminal game, Guess the Word. The agent had to generate the project structure itself, write the code, install dependencies and bring the app to a working state.

In the test, the system did produce a working game with clear logic, score tracking and correct handling of entered characters. This was not a decorative demo but a full local execution of a chain of tasks.

The article is also candid about the limits. The compact quantized model handles basic code, simple scripts, learning projects and research queries well, but falters when a task gets longer and requires sustained multi-step planning. The author notes separately that the model sometimes stopped midway, and he had to nudge it manually with the next command. That is tolerable for experiments, but it looks like a noticeable limitation for a stable day-to-day pipeline.

"Sometimes I just had to type continue so it would finish the task."

What this means

The KDnuggets guide points to an important shift: local agentic AI stacks are becoming cheaper, simpler and more useful in everyday development. They do not yet replace strong cloud models, but they already offer a workable option for private experiments, learning, prototypes and small engineering tasks.