SERIES Part 1 Part 2 Part 3 Part 4 Part 5 Part 6 Part 7 Part 8 Part 9 Part 10
AMD Field AI Enthusiast · by Pradeep Nallimelli · Part 9 of 10+ · June 2026

Four days. 49,288 requests.
Zero errors.

The bench numbers from Parts 1 through 6 said the card could do this. The four-day telemetry says it does. One Radeon AI PRO R9700, one Qwen3-30B-A3B-AWQ model, ten background agents, four ingestors, three frontends. No retries. No fallbacks. No restarts. Here is the production verdict and what it means for sizing a agentic AI node.

Uptime4 days
vllm-qwen3-moe container has not restarted since launch
Errors0
0 abort, 0 error finish reasons across 49,288 successful calls
Throughput12,322
Requests per day, sustained, at p50 0.3% CPU and 100% GPU
HEADLINE NUMBERS

The four numbers that matter.

If you only remember four numbers from this nine-part series, remember these. They define what a 32 GB RDNA4 card can do as an always-on agentic AI host.

Requests served49,288
Lifetime since container launch. 44,111 stop + 5,177 length, 0 abort, 0 error.
Mean time to first token368 ms
vLLM time_to_first_token_seconds_sum / _count. Continuous batching keeps prefill latency flat.
Mean end-to-end latency8.92 s
Per request, including the long-context prefills that dominate the workload mix.
Token throughput127 tok/s
Per-request average over the 4-day window. Aggregate batched decode under 23–24 concurrent agents has been observed at ~450–480 tok/s — the same R9700 that does ~50 tok/s for one user scales nearly 10× under real concurrent load.
PREFILL LATENCY HOLDS UP

TTFT stays flat under continuous load.

368 ms mean time-to-first-token over 49,294 samples. This is the number that defines whether the agents feel snappy. It held flat across four days of continuous load — no degradation as VRAM filled with KV cache, no tail spikes that would block the verify loop.

Latency budget breakdown — mean per request, 4-day window

Source: vLLM time_to_first_token_seconds_sum=18164 / _count=49294 -> 368 ms TTFT; e2e_request_latency_sum=439745 / _count=49288 -> 8.92 s total. Decode time is the remainder.
WHO IS CALLING THE MODEL

Three loops, one endpoint.

Synthesis dominates volume. Verification keeps the brain honest. User-facing Q&A is a minority of requests but the most latency-sensitive. vLLM continuous batching flattens all three into one rolling forward pass.

Daily call volume by request class — production traffic mix

Source: agent_runs.db + verify_worker logs + agent.py session log. 4-day window divided by 4 to get per-day. Total ~12.3k req/day.
RESOURCE BILL

What this workload actually costs.

The full agentic stack — including the model serving, all ten background agents, all four ingestors, all three frontends, the brain databases, and the perf dashboards — fits on one EPYC socket and one R9700 with room to spare.

ResourceUsedAvailableUtilization
GPU compute (R9700)~100% during batches1 cardSaturated by design
GPU memory29.7 GB32 GB93%
GPU power92-143 W300 W TBP31-48%
GPU temp (junction)77 C110 C limit70%
Host CPU (p50)0.3%96 cores / 12 CCDs<1%
Host CPU (p95)12.9%96 cores / 12 CCDs~13%
Host memory24.5 GB peak755 GB3.2%
The R9700 is the constraint. Everything else is headroom. An agentic AI node does not need a top-bin CPU. It needs one good GPU and a CPU big enough to feed it. The Genoa-class EPYC here is doing the work of 16 — but the 12 CCDs are what make it quiet under load, not the core count.
SIZING GUIDANCE

What you need to build the same node.

Based on four days of real telemetry. Not a spec sheet. Not a projection.

ComponentMinimum that workedWhy
GPURadeon AI PRO R9700 (32 GB)Holds Qwen3-30B-A3B-AWQ at 90% mem-util with 32k context
GPU memory32 GB minimumBelow this, drop to dense 14B (Part 1) or to 8B class
CPU16-24 cores (2-3 CCDs)p95 measured at <13% of 96 cores. 2 CCDs covers normal load; a 3rd absorbs speech-preprocessing bursts cleanly.
Host memory64 GBWorking set is 24 GB peak. 64 GB covers SQLite WAL + page cache + the speech preprocessor buffers comfortably.
Storage1 TB NVMethe retrieval store + the synthesis store + meetings.db + agent_history.db = single-digit GB. The rest is for ingested files.
OSUbuntu 24.04 + ROCm 7.2.1The exact stack that produced these numbers
SIX LESSONS FROM PRODUCTION

What four days of telemetry actually taught us.

Each lesson cost engineering time. None of them came from a spec sheet.

1MoE wins
Qwen3-30B-A3B at 51 tok/s single-stream beats dense 14B at 7.5 tok/s on the same card. Always pick the right shape first (Part 2).
2Prefill bound
35 M prompt vs 8.7 M decode. Prefill bandwidth is the bottleneck for agentic, not single-stream decode.
3CPU is the conductor
Ingestion, embeddings, orchestration, speech/doc pre-processing — the CPU is constantly working. A weak CPU here turns the GPU into expensive overkill. A right-sized EPYC keeps the GPU fed end-to-end.
4Single writer
One process per store. No write contention. The entire brain pipeline is built on this rule.
5Verify always
Continuous fact-check + re-synth is what separates an agent from a confident liar.
6Privacy at the router
One switch in verify_worker decides local vs gateway. Customer rows never leave.
CLOSE

One card. The card you can buy. A real workload.

Nine parts, three runtimes, six benchmarks, and a four-day production run. The thesis was that a single Radeon AI PRO R9700 could host an entire agentic AI stack for a working AMD Field team. The thesis held.

49,288 requests. 35.24 million prompt tokens. 8.73 million generated. Zero errors. One model. One GPU. One box. The card that started this series as a bench target now runs my actual job.

Series total9 parts
From "meet the card" to "49,288 production requests"
Hardware1 GPU
Radeon AI PRO R9700, 32 GB, gfx1201, ROCm 7.2.1
OutcomeReference
A reproducible single-node design anyone can build. Part 10 maps this loop to AMD's datacenter agentic blueprint.