Best Local AI Models for Coding in 2026: Qwen3.6, Devstral Small 2, and GLM-4.7-Flash (Compared)

Qwen3.6-27B is the best local AI model for coding for most developers in 2026, but its 17 GB Ollama package is the beginning of the memory bill, not the end. If you are buying hardware only to avoid a $10 monthly Copilot Pro seat, a $1,999 RTX 5090 takes 199.9 months to cross over before power, the rest of the workstation, or your time.

The short answer: choose the model your memory can sustain

Pick Qwen3.6-27B if you have a 24 GB-class GPU or unified-memory machine and want one strong local default for repository work, tool use, and everyday reasoning. Pick Devstral Small 2 when the job is specifically multi-file software engineering and your machine matches Mistral's single RTX 4090 or 32 GB Mac guidance. Choose GLM-4.7-Flash when you want an efficient agent model and can tolerate a younger local-serving stack. Reserve Qwen3-Coder-Next for a 64 GB machine or shared server. On an 8 GB-class system, use Qwen3.5-9B for bounded edits rather than pretending it is a repo-wide autonomous engineer.

Prices, model cards, runtime memory listings, and licenses below were verified against live vendor pages on August 15, 2026.

The ranking uses a fit-first rule: available accelerated or unified memory first, coding workflow second, benchmark score third. That order prevents the most common buying error in local AI. A model can fit as a file yet leave too little memory for a useful context window, the runtime, the operating system, and the coding agent that is feeding it files and tool results.

Three numbers that look similar describe different constraints:

1. Package size is the quantized model download. Ollama lists the qwen3.6:27b package at 17 GB.
2. Minimum system memory is the runtime's load floor. LM Studio lists 16 GB for the same model, but a minimum is not a comfortable working target.
3. Context memory grows as the conversation, source files, command output, and tool history grow. Qwen explicitly tells users to reduce context after an out-of-memory error, even though the model supports a much larger native window.

Think of the model file as a person entering an elevator. Fitting through the door proves only that the passenger can get inside. A coding agent also needs room for luggage: repository context, generated tokens, runtime buffers, and the tools around it. Filling the elevator to its stated limit is a poor way to plan a working day.

If your goal is the complete editor, review, and cloud-agent experience rather than the underlying model, compare the current AI coding assistants. A local model is one component. It does not automatically provide repository indexing, permission controls, a patch review surface, sandboxing, or a safe command runner.

1. Qwen3.6-27B: best local AI model for coding overall

Qwen3.6-27B is the best default because it puts current agentic coding, tool use, vision input, and repository-level reasoning into a 17 GB Ollama package. It suits a developer who wants one model to inspect a TypeScript monorepo, explain a failing test, draft a patch, and reason through adjacent product logic without switching models. The wall is memory headroom: LM Studio's 16 GB minimum and Ollama's 17 GB package do not make a 16 GB machine a comfortable long-context coding workstation. Buy or allocate around the context you will use, not the smallest number on the download page.

Qwen's official model card describes a 27B-parameter model with a 262,144-token native context window, extensible to 1,010,000 tokens. It also names agentic coding, tool use, frontend workflows, repository reasoning, vision input, and preservation of reasoning context across historical messages. Those are useful coding-agent ingredients because a repository task rarely ends after one answer. The model must retain why it chose an approach after tests, logs, and new files enter the conversation.

The current Ollama tag listing makes the release practical: qwen3.6:27b is a 17 GB download with a 256K context listing. A coding-focused NVFP4 package is 20 GB. LM Studio lists a 16 GB minimum system memory, but that is a load-floor signal. On a 24 GB-class GPU or unified-memory machine, the 17 GB package leaves materially more room for context and runtime overhead. On 16 GB, start with a smaller context or a smaller model.

The headline benchmark is strong but needs its method attached. Qwen reports 77.2 on SWE-bench Verified, 53.5 on SWE-bench Pro, 71.3 on SWE-bench Multilingual, and 59.3 on Terminal-Bench 2.0. Its SWE-bench results used an internal agent scaffold with bash and file-edit tools plus a 200K context window. Terminal-Bench used a 256K context window on a harness with 32 CPUs and 48 GB of RAM. Those numbers show capability under Qwen's setup; they do not promise the same result or speed on a 24 GB desktop.

There is a second context warning in the vendor documentation. Qwen says to reduce the context after an out-of-memory error, while also advising at least 128K context to preserve complex-task thinking capability. That tension is the model's named wall. The model can expose a 256K window, but a compact local machine may force you to run less of it.

Best for: Developers with a 24 GB-class GPU or unified-memory machine who want one broad local coding model

Standout: A 17 GB one-click package with current tool use, repository reasoning, and vendor-reported 77.2 SWE-bench Verified

Pricing: $0 through LM Studio's local Free tier, verified August 15, 2026

Free trial: Not applicable; the local runtime tier and model download are free

Set up Qwen3.6-27B without mistaking maximum context for a target

1. 1

   Check memory before downloading

   Record available VRAM or unified memory, not just total disk space. Treat 24 GB as the practical starting tier for the 17 GB package. If the machine has only 8 GB, skip directly to Qwen3.5-9B.

2. 2

   Install LM Studio and choose the exact model

   Install LM Studio on a supported Apple Silicon, Windows, or Linux machine. Search for Qwen3.6-27B, confirm that the publisher is Qwen, and select a quantization whose displayed size leaves working headroom.

3. 3

   Start below the maximum context

   Do not begin at 256K merely because the model supports it. Start with a context sized for one representative repository task, watch memory use, and increase only when the additional files improve the patch more than they slow or destabilize the run.

4. 4

   Expose the local server to one coding agent

   Enable LM Studio's local server and point one OpenAI-compatible coding client at it. Keep the server bound to the local machine unless you have intentionally added network authentication and access controls.

5. 5

   Pilot one bounded repository task

   Use one bug with a known failing test, a small multi-file change, and one explanation task. Review every proposed command and diff. Record accepted patches, correction time, peak memory, and whether the model lost earlier constraints.

2. Devstral Small 2: best dedicated local coding agent

Devstral Small 2 is the focused pick for a developer who wants the model to explore a codebase, edit several files, and operate through software-engineering tools. Mistral designed the 24B model for agentic coding rather than positioning it as a general assistant that also writes code. A team maintaining a large Python service can give it a contained issue, let the harness search and edit, then review a coherent multi-file patch. Its wall is the gap between merely loading and working comfortably: LM Studio says 16 GB minimum, while Mistral names a single RTX 4090 or a Mac with 32 GB RAM as the local deployment target.

The official Mistral model card gives Devstral Small 2 a 256K context window, vision input, and tool use for repository exploration and multi-file edits. It is also Apache 2.0 licensed, which gives a commercial team a clearer starting point for use and modification than a vague community upload. Legal review can still be required for the surrounding code and deployment, but the model license itself is explicit.

Mistral reports 68.0% on SWE-bench Verified, 55.7% on SWE-bench Multilingual, and 22.5% on Terminal Bench 2. Those scores trail Qwen3.6's reported headline on two overlapping benchmarks, but raw rank is not the whole choice. Devstral's product boundary is narrower and easier to explain: it is a software-engineering agent model built to use tools, inspect code, and edit files.

The memory recommendation should settle the hardware question. LM Studio lists 16 GB as its minimum, yet Mistral says the model is light enough for a single RTX 4090 or a 32 GB Mac. Follow the named machine guidance when buying hardware. Treat the smaller number as evidence that a quantized file can load, not that a long agent run will retain the context you want.

Best for: A dedicated multi-file coding agent on a high-end single workstation

Standout: Explicit software-engineering-agent training, 256K context, vision, and Apache 2.0 licensing

Pricing: $0 through LM Studio's local Free tier, verified August 15, 2026

Free trial: Not applicable; the local runtime tier and model download are free

3. GLM-4.7-Flash: best efficient mixture-of-experts option

GLM-4.7-Flash is the efficient experimenter's choice: a 30B mixture-of-experts model that activates 3B parameters per token and is packaged at 19 GB in Ollama. It fits a builder who wants agent behavior on a 24 GB-class machine and is willing to validate a newer serving path before standardizing it across a team. Z.ai reports competitive coding results for its size and LM Studio exposes tool and thinking controls. The wall is integration maturity: the official model card says vLLM and SGLang support relied on their main branches, which is a warning for production environments that prefer pinned stable releases.

A mixture-of-experts model stores many parameter groups but activates only a subset for each token. The 3B active figure helps explain compute efficiency; it does not turn the model into a 3B download. The Ollama tags page lists the Q4 package at 19 GB, while LM Studio lists 16 GB minimum system memory and a 128K context. The package number is the more useful reminder when planning accelerated memory.

Z.ai's official model card reports 59.2 on SWE-bench Verified and 64.0 on LiveCodeBench v6. The model is trained for tools and offers thinking controls through LM Studio. It can be a compelling local agent model when throughput per active parameter matters, but the evaluation scores are still vendor-reported and the serving stack deserves a pilot.

For a small internal platform team, the sensible use case is one local service behind a coding client, pinned to a known model file and runtime version. Run repository search, patch generation, tool-call parsing, and long-output tests before giving it a shared endpoint. If the team cannot reproduce the environment after an update, the efficiency win has not become an operational win.

Best for: Builders testing an efficient agent model on a 24 GB-class machine

Standout: 30B total parameters with 3B active per token, tool training, and a 19 GB Ollama package

Pricing: $0 through LM Studio's local Free tier, verified August 15, 2026

Free trial: Not applicable; the local runtime tier and model download are free

4. Qwen3-Coder-Next: best for a 64 GB local agent server

Qwen3-Coder-Next is the specialist for a memory-rich local server, not the bargain model its 3B-active label can suggest. Qwen designed it specifically for coding agents and local development, with long-horizon reasoning, complex tool use, and recovery from execution failures. It makes sense for a small platform team centralizing a controlled local agent endpoint where 64 GB of unified or system memory is available. Its wall is physical: the current Q4 Ollama package is 52 GB, so a normal 24 GB developer GPU is not the target.

The Qwen model card describes 80B total parameters with 3B active per token, a 262,144-token native context, and non-thinking mode only. It is trained for coding-agent work rather than static code completion alone. Qwen specifically calls out long-horizon tasks, tool use, IDE and CLI integration, and recovery after an execution failure.

The download tells the hardware story. Ollama lists the Q4 package at 52 GB and Q8 at 85 GB, both with a 256K context listing. LM Studio lists a 42 GB minimum system memory. Planning around 64 GB for Q4 gives the operating system and a reduced context some space, but it still does not guarantee that the full native window will be comfortable.

Qwen acknowledges that boundary. Its official guidance says to reduce context to 32,768 if the server fails to start or encounters an out-of-memory condition. That is a more useful deployment instruction than the maximum context number. A reliable 32,768-token agent session that edits and tests the right files is worth more than a 256K checkbox that repeatedly crashes.

The model's non-thinking behavior can also be an advantage or a limit. It avoids exposing a long reasoning phase and can keep interaction direct, but a buyer who explicitly wants preserved thinking should choose Qwen3.6 or evaluate another model. Do not infer identical behavior from the shared Qwen name.

Best for: A 64 GB local server serving one or a few controlled coding-agent workloads

Standout: Coding-agent specialization with 80B total parameters, 3B active per token, and recovery-oriented training

Pricing: $0 through LM Studio's local Free tier, verified August 15, 2026

Free trial: Not applicable; the local runtime tier and model download are free

5. Qwen3.5-9B: best for 8 GB-class hardware

Qwen3.5-9B is the sensible small-machine choice for explanations, snippets, test generation, and tightly bounded edits. LM Studio lists a 7 GB minimum, so the model can serve a developer on an 8 GB-class machine who cannot fit the 17 GB to 52 GB packages above. Its model card includes thinking, tools, vision, and agent capabilities, making it more versatile than an older autocomplete-only model. The wall is scope: it is a 9B general foundation model, not a license to hand an entire repository to an unattended agent.

The official Qwen3.5-9B card gives the dense model a 262,144-token native context, extensible to 1,010,000 tokens. Qwen reports 65.6 on LiveCodeBench v6, 66.1 on BFCL-V4, and 79.1 on TAU2-Bench. LiveCodeBench measures code generation, while BFCL and TAU2 probe tool and agent behavior; none is the same as completing a particular repository issue through your coding harness.

The context headline needs the same restraint as the larger models. Qwen says to reduce context after an out-of-memory error and advises at least 128K for preserving complex-task thinking. An 8 GB-class machine is unlikely to pair the model with that much working context comfortably. Use modest context, pass only the files required for the task, and prefer a sequence of reviewable edits over one long autonomous run.

A good use case is a developer learning an unfamiliar function: supply the function, its tests, and the relevant type definitions; ask for an explanation and a minimal patch; then run the tests yourself. A poor use case is asking the model to inspect a large monorepo, redesign an architecture, edit dozens of files, and recover from failures without supervision. The smaller model wins by being available, not by erasing the cost of complexity.

Best for: Snippets, explanations, tests, and bounded diffs on an 8 GB-class machine

Standout: 7 GB LM Studio minimum with current thinking, vision, and tool capabilities

Pricing: $0 through LM Studio's local Free tier, verified August 15, 2026

Free trial: Not applicable; the local runtime tier and model download are free

Who should pick what?

The choice becomes simple once memory and workload are stated together.

On an 8 GB Mac or similar small machine: choose Qwen3.5-9B and keep context modest. LM Studio's system requirements tell 8 GB Mac users to stick to smaller models and modest context. Expect useful explanations, snippets, and limited diffs, not unattended repo-wide work.

On a 16 GB machine: do not treat the largest model that barely loads as the winner. Qwen3.6 and Devstral both have 16 GB LM Studio minimums, but that leaves almost no room around the model. A smaller quantization, Qwen3.5-9B, or a short-context pilot is the safer start.

On a 24 GB-class GPU or unified-memory machine: Qwen3.6-27B is the default. Devstral Small 2 flips the choice when multi-file software engineering is nearly the whole workload. GLM-4.7-Flash flips it when mixture-of-experts efficiency is worth extra runtime validation.

On a 32 GB Mac or RTX 4090-class workstation: Devstral Small 2 has the clearest vendor-backed fit. Qwen3.6 remains the broader assistant, so the decision is focused coding agent versus wider reasoning and vision work.

On a 64 GB machine or local server: Qwen3-Coder-Next becomes viable. Its 52 GB Q4 package still calls for a context budget, and the server needs an access and concurrency plan. A model being local does not mean every developer should expose an unauthenticated endpoint across the office network.

The flip rule is compact: if two models fit, choose the one trained closest to the job; if only one leaves headroom, choose the one that leaves headroom. Benchmark rank cannot rescue a model that spends the workday swapping, crashing, or running with too little context to understand the change.

The local-seat crossover: when hardware belongs in the budget

Local weights begin at $0, but local coding does not. The bill moves from a subscription to hardware, electricity, setup, updates, access control, and developer time. A machine you already own changes the decision. A machine bought only for local inference must earn its line item.

LM Studio's Free tier costs $0, runs local models on the user's machine, and states that no data leaves the device. Its system documentation says the application can run entirely offline after the model files are downloaded. That privacy and offline boundary can justify local inference even when the subscription comparison does not. It can matter for unreleased source code, field work without stable connectivity, or a team that needs model availability independent of a provider outage.

The clean budget comparison uses public sticker lines, not a promise of total cost. NVIDIA launched the 32 GB RTX 5090 at a $1,999 starting price. GitHub's current individual plans list Copilot Free at $0, Pro at $10 per user per month, Pro+ at $39, and Max at $100. Organization pricing is $19 per user per month for Business and $39 for Enterprise.

• One $10 Pro seat takes 199.9 months, about 16.7 years, to equal a $1,999 GPU starting price.
• Ten Business seats cost $190 per month. The GPU sticker price equals 10.5 months of that line.
• Ten Enterprise seats cost $390 per month. The GPU sticker price equals 5.1 months of that line.

That consequence is more useful than a release spec. Do not buy a high-end GPU merely to eliminate one $10 cloud seat. Buy because the code boundary must remain local, offline access has operating value, the hardware already exists, or a team can share capacity without turning one machine into a queue.

Cloud seats also buy more than inference. A coding-assistant plan can include hosted models, editor integration, cloud agents, code review, identity, policy, and support. A local model download buys none of those controls by itself. If metered inference is a better comparison than a seat, the cheapest AI API analysis shows why token price is only one part of the application bill.

The Monday decision is therefore asymmetric. A solo developer with an existing 24 GB GPU should try Qwen3.6 before paying for another service. A solo developer with no suitable hardware should begin with a cloud seat or Qwen3.5 on the current machine. A ten-person team with sensitive code should run a two-week shared-server pilot and measure concurrency, accepted patches, correction time, and operator hours before buying a fleet.

How these local coding models were picked

The five models were selected for a decision a developer can execute today, not for the longest possible name list. Each choice has a distinct memory tier or coding job, and each is documented deeply enough to reveal the machine and workflow where it stops being the right pick.

Six criteria set the order:

1. Local availability: The model needs a current official card plus a current one-click LM Studio or Ollama listing.
2. Hardware fit: Package size, minimum memory, context pressure, and the vendor's named machine guidance are considered together.
3. Coding-agent behavior: Tool use, multi-file edits, repository reasoning, recovery from failures, and coding-harness support matter more than autocomplete alone.
4. Operational maturity: A reproducible runtime and clear out-of-memory guidance count. Main-branch-only serving support is a cost, even when the weights are free.
5. Current terms: Prices and licenses come from live vendor pages. A clear license is a meaningful advantage for a commercial deployment.
6. Transparent evidence: Vendor benchmarks are useful only with their scope and harness attached. Scores from different scaffolds are not treated as one clean league table.

No model was exercised during this run, so the title says Compared, not Tested. The ranking uses current model cards, runtime pages, disclosed evaluation methods, and original cost analysis. A vendor benchmark and a patch accepted in your repository remain different kinds of evidence.

The list excludes models that are impressive but not practical on a single current workstation. A 480B model can be open-weight and technically self-hostable while still being the wrong answer to a developer asking what to run locally. It also excludes models that lack a current, reproducible local package or that can only be described with general praise.

The ones to avoid for this job

Avoid giant models presented as ordinary local choices. The largest Qwen3-Coder, Kimi, and GLM flagships may be open and self-hostable, but that does not make them a single-workstation recommendation. Without an exact quantization, memory plan, runtime, and concurrency target, “local” is only a deployment possibility.

Avoid choosing by active parameter count alone. GLM-4.7-Flash and Qwen3-Coder-Next each activate 3B parameters per token, yet their quantized Ollama packages are 19 GB and 52 GB. Active computation and stored weights answer different questions. The GPU must still hold or move the package it runs.

Avoid making Code Llama or StarCoder2 the fresh default. Older code models can remain useful for a pinned workflow, especially when a team already understands their behavior. For a new 2026 setup, current agent-trained models add tool use, longer-context behavior, and recovery-oriented training that better matches how coding agents work.

Avoid an experimental community quantization as the team baseline. A community build can be excellent, but record the exact file, quantization, prompt template, runtime version, license, and checksum before several developers depend on it. If the result cannot be reproduced after an update, the local setup has traded provider dependence for artifact dependence.

Avoid maximal context on day one. A 256K model page is not an instruction to allocate 256K for every task. Start with the smallest context that contains the relevant code and tool history. Increase it after a failed patch demonstrates missing information, not because a slider allows it.

Frequently asked questions

What is the best AI model for coders?

For a local setup, Qwen3.6-27B is the best general default on a 24 GB-class machine. Devstral Small 2 is better when the workload is specifically multi-file software engineering, while a managed cloud model can still be the better system when concurrency, maintenance, or hosted tooling is the constraint.

What is the best local AI model for coding in 2026?

Qwen3.6-27B is the best overall choice because its 17 GB Ollama package combines current coding-agent behavior with broad reasoning and vision. Use Devstral Small 2 for a focused code agent, Qwen3-Coder-Next on a 64 GB server, and Qwen3.5-9B on an 8 GB-class machine.

What is the best local AI model right now?

The best model is the strongest one that leaves memory for useful context and the runtime. Qwen3.6-27B wins the common 24 GB tier; a smaller Qwen3.5-9B can be better on an 8 GB machine because it runs with a workable context instead of merely loading.

What is the best self-hosted AI model for coding?

Qwen3-Coder-Next is the specialist choice for a 64 GB local server because it was designed for coding agents, long-horizon tool use, and recovery from failures. Qwen3.6-27B is the more practical self-hosted default when the server or workstation has about 24 GB of accelerated or unified memory.

Which Ollama model is best for coding?

Start with qwen3.6:27b when the machine has room for the 17 GB package plus context and runtime overhead. On a compact machine, use a smaller Qwen3.5 package; on a 64 GB server, evaluate Qwen3-Coder-Next and begin with reduced context.

How much RAM or VRAM do I need for a local coding model?

Use 8 GB-class hardware for Qwen3.5-9B and bounded tasks, about 24 GB for Qwen3.6-27B or GLM-4.7-Flash, a 4090-class PC or 32 GB Mac for Devstral Small 2, and about 64 GB for the 52 GB Qwen3-Coder-Next package. These are practical targets, not guarantees; context, quantization, runtime, operating system, and GPU offload change the final requirement.

Are local AI coding models free?

The five model downloads and LM Studio's local tier begin at $0. The system is not costless: hardware, electricity, setup, updates, access control, backup, and engineering time remain part of ownership.

Your Monday move

Do not start by ordering a GPU. Start with a one-repository fit test.

Monday: inventory the machine and choose one candidate

Record available VRAM or unified memory, system RAM, operating system, and whether the machine already supports LM Studio. Choose Qwen3.5-9B for an 8 GB-class system, Qwen3.6-27B for a 24 GB-class system, or Devstral Small 2 for the 4090/32 GB Mac tier. Do not download all five.

Tuesday: define three representative tasks

Use one failing test with a known fix, one small multi-file change, and one explanation task from a repository the team understands. Remove secrets and grant the coding agent only the tools the task requires. Save the expected behavior before starting.

Wednesday: run below maximum context

Begin with a bounded context and the smallest relevant file set. Record peak memory, time to first useful patch, commands requested, tests passed, and human corrections. If the model misses a dependency, add the missing file before expanding the entire context window.

Thursday: compare with the current cloud path

Run the same three tasks through the assistant or API already being paid for. Compare accepted patches and correction minutes, not prose confidence. Include setup and operator time on the local side.

Friday: make one of three decisions

Keep local if privacy, offline use, control, or accepted-patch economics improved. Keep the cloud seat if it remains cheaper and easier. Upgrade hardware only when the pilot identifies memory as the limiting factor and the local benefit is worth owning the machine.