---
license: mit
task_categories:
  - text-generation
tags:
  - local-llm
  - agent
  - coding-agent
  - benchmarks
  - 8gb-vram
  - hermes-agent
  - pi-coding-agent
  - moe-offload
  - tool-calling
  - gbnf-grammar
  - structured-cot
  - constrained-decoding
size_categories:
  - n<1K
---

# 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.

five 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)
- **OmniCoder-9B** (9B dense, 42 tok/s, Tesslate, based on Qwen3.5-9B, fine-tuned on 425K agentic trajectories)

## 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.

8. **agentic fine-tuning helps code quality, not agent loops.** OmniCoder-9B (Tesslate, 425K agentic trajectories on Qwen3.5-9B) produced the cleanest first-shot code of any model tested: 83-line portscout in <1 min with no self-fixes needed. but it failed on the hard task the same way Qwopus 9B did: ran a blocking command without timeout, then got stuck in a generation loop. code generation and agent loop management are separate skills, and fine-tuning on coding trajectories doesn't fix the latter.

9. **thinking mode is a trap for 9B models.** OmniCoder-9B with default thinking mode burned all tokens on reasoning_content with 0 code output (same as Qwen3.6). the `-rea off` server flag is mandatory. once disabled, the model is fast (42 tok/s) and produces clean direct output.

## deep-dive benchmark: gpt-oss-20b (8 additional prompts)

after the initial comparison, we ran 8 more prompts through gpt-oss-20b to stress-test reliability across different coding skills.

| # | task | difficulty | status | context used | self-fixes | key finding |
|---|---|---|---|---|---|---|
| 1 | bug fix | easy | pass | 13% | 0 | rumination wastes tokens but doesn't cause failures |
| 2 | feature addition | medium | pass | compacted | 2 | hallucinated json.__stdout__, self-corrected to sys.stdout |
| 3 | TDD | medium | pass | compacted | 2 | eval() shortcut, ls -R ~ dumped 11K lines into context |
| 4 | data pipeline | medium | pass | 19.7% | 0 | cleanest run, proper /proc parsing |
| 5 | hallucination trap | easy | pass | 6.3% | 0 | no fake modules, real stdlib only (http.client, json, time) |
| 6 | error recovery | medium | pass | 16.8% | 1 | sed quoting bug, chose bash-only YAML parsing |
| 7 | multi-module | hard | pass | 47.6% | 1 | topological sort direction bug, fixed with reversed() |
| 8 | bash scripting | medium | pass | 23% | 1 | printf format bug, 4 failed edit attempts |

**result: 8/8 pass.** combined with the 2 original tasks (portscout + logpulse), gpt-oss-20b completed 10/10 agentic coding tasks on 8GB VRAM.

**consistent patterns:**
- **self-correction works**: 7 total self-fixes across 8 tasks. model finds its own bugs and fixes them.
- **context efficiency**: 6-48% usage per task, no task exhausted the 32K window.
- **no hallucinated APIs**: passed the stdlib-only trap cleanly.
- **edit tool weakness**: exact string matching fails repeatedly, model falls back to full file rewrites.
- **directory scan waste**: runs `ls -R` from home, dumping 11K+ lines into context (2 of 8 prompts).
- **rumination**: debates obvious decisions, wasting tokens without causing failures.

## verdict

**gpt-oss-20b + Pi is the first viable local coding agent on 8GB VRAM.** it completed 10/10 agentic coding tasks: the original easy + hard comparison tasks, plus 8 deep-dive prompts covering bug fixes, feature additions, TDD, data pipelines, hallucination traps, error recovery, multi-module projects, and bash scripting. 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) |

## GBNF structured CoT experiment (2026-05-21)

finding #3 above says "thinking mode is unusable for agentic work." can we fix that? the structured CoT approach (credit: andthattoo/structured-cot) uses a 4-rule GBNF grammar to force the model into a strict think-then-code pattern:

```
root  ::= think code
think ::= "<think>\n" "GOAL: " line "APPROACH: " line "EDGE: " line "</think>\n\n"
line  ::= [^\n]+ "\n"
code  ::= [\x09\x0A\x0D\x20-\x7E]+
```

the grammar constrains the full output stream (including reasoning_content). results on Qwen3.6-35B-A3B:

### easy tasks: grammar vs free-form

| task | free tokens | grammar tokens | compression | free time | grammar time | code produced |
|---|---|---|---|---|---|---|
| fibonacci | 2048 (max) | 365 | 5.6x | 63.6s | 12.2s | free: 0 lines, grammar: valid |
| fizzbuzz variant | 2048 (max) | 179 | 11.4x | 63.9s | 5.9s | free: buried in reasoning, grammar: valid |
| flatten dict | 2048 (max) | 450 | 4.6x | 64.5s | 15.2s | free: 0 lines, grammar: valid |

**free-form Qwen3.6 hit the token limit on all 3 tasks.** it burned the entire 2048-token budget on reasoning and produced zero usable code on 2 of 3 tasks. the grammar compressed output 6.2x overall and every task produced correct, valid Python.

### hard tasks: 3-field vs 5-field grammar

we also tested a 5-field variant (GOAL/STATE/ALGO/EDGE/VERIFY) on harder problems:

| task | 3-field tokens | 5-field tokens | 3-field time | 5-field time | both valid |
|---|---|---|---|---|---|
| topological sort | 437 | 545 | 15.0s | 17.2s | yes |
| LRU cache (O(1)) | 964 | 930 | 31.8s | 29.3s | yes |
| merge intervals | 319 | 341 | 11.5s | 10.8s | yes |

the 5-field grammar adds marginal value on complex tasks (caught a node-collection edge case on topo sort, used `__slots__` on LRU cache) but the improvement doesn't justify the extra token cost for general use.

### verdict

the 3-field grammar (GOAL/APPROACH/EDGE) is the sweet spot. it eliminates rumination, compresses tokens 4.6-11.4x, speeds up generation 5x, and produces valid code on 6/6 tasks. the model already knows the answers, it just needs to stop overthinking.

**key caveat:** this was tested on direct code generation, not agentic tool-call generation. applying grammar to an agent loop would require a grammar that handles both code and JSON tool calls.

## related

- inference speed benchmarks (same hardware): [witcheer/windows-rtx-4060ti-8gb-moe-offload-bench-2026-05](https://huggingface.co/datasets/witcheer/windows-rtx-4060ti-8gb-moe-offload-bench-2026-05)
- model collection: [8GB VRAM local LLMs, practitioner-tested](https://huggingface.co/collections/witcheer/8gb-vram-local-llms-practitioner-tested-69fa0e855c51e3c15a9d95d4)