one million tokens, ten hours, three cves

opencode, pointed at a local qwen, left alone for about ten hours. it came back with roughly a million output tokens, three promising cves, and proof-of-concept scripts that actually worked. clean run — no restarts, no oom, no drama.

the box

the gpu box — four cards, all of them in pcie 1.1 x16 after the soldering job, 270 t/s of prompt processing and 35 t/s of generation. the model is qwen3.8 27b, uncensored, q6_k. on this box i go one quant harder than on the $500 cpu box, because the gpus can afford it — and the uncensored weights don't flinch when an agent starts thinking out loud.

the launch

verbatim:

./build/bin/llama-server \
  -m /mnt/ssd2/Qwen3.8-27B-Uncensored-Q6_K.gguf \
  -ngl 999 -ctk f16 -ctv f16 -b 2048 -ub 2048 \
  -c 184000 \
  -fa on \
  --jinja \
  --port 11435 --spec-draft-n-max 4 \
  -t 8 --no-mmap --host 0.0.0.0 -np 1 --verbosity 4 \
  -sm tensor --cache-ram 78000 \
  --chat-template-kwargs '{"enable_thinking": true}' \
  --numa isolate \
  --reasoning-preserve

what each part buys you:

• -ngl 999 — every layer on the gpus; the cpu just waits
• -ctk f16 -ctv f16 — an honest f16 kv cache, no quantized-memory artifacts on a model that thinks for hours
• -b 2048 -ub 2048 — fat prompt batches; this is where the 270 t/s of prompt processing comes from
• -c 184000 — 184k context. the entire multi-agent session lives in one context
• -fa on — flash attention, so 184k of attention stops eating the vram
• --jinja — the model's own chat template, not a hand-rolled one
• --port 11435 — the openai-compatible endpoint opencode talks to. that's the whole wiring
• --spec-draft-n-max 4 — speculative decoding, up to four draft tokens per step
• -t 8 --no-mmap — eight host threads, the model fully in ram, no page faults mid-thought
• -sm tensor — tensor-level split across the four cards
• --cache-ram 78000 — ~78 gb of kv cache overflowed into system ram; this is how a 184k f16 cache fits at all
• --numa isolate — no cross-socket traffic on the host side
• --chat-template-kwargs '{"enable_thinking": true}' — thinking mode on
• --reasoning-preserve — the reasoning stays in context between turns, so ten hours of thinking doesn't evaporate

the run

opencode spawned at least three agents to comb the internet for promising cves. it picked the three most promising, and — again with subagents — wrote reports on them. other subagents read those reports plus the source code and wrote poc scripts. the pocs worked: they ran against targets in docker, which got pawned itself.

the numbers

output tokens	~1,000,000
wall time	~10 h
effective rate	~3 t/s
generation, when it's actually generating	35 t/s
prompt processing	270 t/s
compactions past 140k tokens	12+
crashes / ooms	0

why ~3 t/s on average when generation does 35? because the agents don't reason all the time — they use tools. builds, docker, the internet, prompt processing, and context switching all burn wall time without producing a single token. the 12 gb of kv cache sized for one 120k context fills up the moment several agent contexts exist at once, and the compactor ran 12+ times past 140k tokens to keep each session honest.

what made ten hours possible

three flags did most of the work: -c 184000, so the whole job fits in one context; --reasoning-preserve, so the model remembers why it started something four hours ago; and -fa on with --cache-ram, so that context physically fits. a local model, no terms of service, ten uninterrupted hours of work.