witcheer/local-agentic-coding-bench-8gb-vram-2026-05

agentic coding benchmark: local LLMs on 8GB VRAM

can local LLMs do agentic coding (multi-turn tool calling, file creation, debugging) on consumer hardware? this dataset captures real test results.

hardware

• GPU: NVIDIA RTX 4060 Ti 8GB
• CPU: Intel i7-14700F
• RAM: 32 GB DDR5
• OS: Windows 11 + WSL2 (Ubuntu)
• inference: llama-server (turboquant fork of llama.cpp)

what was tested

two agent frameworks:

• Hermes Agent (NousResearch): structured tool calling with patch/write/bash tools
• Pi (badlogic): simpler 4-tool interface (read/write/edit/bash)

two coding tasks at different difficulty levels:

• portscout (easy): write a single-file concurrent port scanner using stdlib. create, test, done.
• logpulse (hard): write a multi-file CLI log watcher with real-time stats, regex alerts, a fake log generator, a README, and self-test. requires file creation, debugging, and iterative fixes.

four model configurations:

• Qwopus3.5-9B-Coder (9B dense, 43 tok/s, fully in VRAM)
• Qwen3.6-35B-A3B MoE + thinking (35B MoE, 3B active, 35 tok/s, ncmoe=30, reasoning on)
• Qwen3.6-35B-A3B MoE no-think (35B MoE, 3B active, 35 tok/s, ncmoe=30, reasoning off)
• gpt-oss-20b (21B MoE, 3.6B active, ncmoe=30, OpenAI Apache 2.0, native MXFP4 FFN)

key findings

1. 9B models break on complex tool calls regardless of framework. Qwopus 9B generated good code but failed on structured output: malformed patch JSON in Hermes, infinite reasoning loops in Pi. the model writes code fine but can't plan multi-turn agent actions reliably at 9B params.

2. 35B MoE is reliable but too slow for agent loops. Qwen3.6-35B-A3B never broke a tool call, but expert offload adds 2-5s latency per API call. agent tasks need 20-50+ round trips, compounding to 18-87 minutes for tasks cloud APIs finish in seconds.

3. thinking mode is unusable for agentic work. reasoning tokens consumed most of the generation budget, inflating a 18-minute task to 49 minutes (2.7x overhead).

4. context window is a hard constraint. the 35B model hit the 32K context limit during a debug loop on the hard task. bumping to 40K helped but caused OOM at 48K+ on 15 GB WSL memory.

5. code quality was good across all configs. every model produced clean, working code. the bottleneck is agent loop speed and tool call reliability, not code generation quality.

6. gpt-oss-20b is the breakthrough. OpenAI's 21B MoE (3.6B active) completed both easy and hard tasks quickly via Pi. only 1.8 GB VRAM with ncmoe=30, used just 26% of context on the hard task. first model to complete both agentic tasks on 8GB VRAM. the combination of OpenAI's structured output training + low VRAM footprint + Pi's simple tool interface is the winning formula.

7. agent framework matters as much as the model. Pi's 4-tool interface (read/write/edit/bash) produces fewer tokens per turn and simpler tool call schemas than Hermes Agent's patch-based approach. this reduces context pressure and makes structured output easier for smaller models.

verdict

gpt-oss-20b + Pi is the first viable local coding agent on 8GB VRAM. it completed both the easy task (single-file port scanner) and the hard task (multi-file CLI tool with testing) quickly and reliably. the other configs all failed: 9B too small for tool calls, 35B Qwen3.6 too slow for agent loops.

key recipe:

• model: gpt-oss-20b Q4_K_M (11 GB, 1.8 GB VRAM with ncmoe=30)
• framework: Pi coding agent (simple read/write/edit/bash tools)
• server: llama-server with --jinja, ncmoe=30, -c 32768, -n 8192
• hardware: any 8GB GPU + 16GB+ system RAM

schema

field	type	description
model	string	model name
model_params_total_b	number	total parameters (billions)
model_params_active_b	number	active parameters per token (billions)
quant	string	quantization format
architecture	string	model architecture (dense, moe_ssm_attn)
vram_used_gb	number	VRAM usage during inference
tok_s	number	tokens per second (baseline decode speed)
framework	string	agent framework used (hermes-agent, pi)
reasoning_mode	string	thinking/reasoning mode (on, off)
task	string	task identifier
task_difficulty	string	easy or hard
task_description	string	what the task requires
context_window	number	server context window setting
max_output_tokens	number	max output tokens per generation
wall_clock_min	number	total wall-clock time in minutes
status	string	completed, failed, killed, partial, context_exceeded
tool_call_reliability	string	reliable, partial, broken
failure_mode	string or null	description of how/why it failed
code_quality	string	quality of generated code (good, poor, n/a)
notes	string	additional observations
hardware	string	full hardware description
date	string	test date (YYYY-MM-DD)

related

• inference speed benchmarks (same hardware): witcheer/windows-rtx-4060ti-8gb-moe-offload-bench-2026-05
• model collection: 8GB VRAM local LLMs, practitioner-tested