Two GGUF paths, same weights. Bare llama-server loads Gemma 4 E4B and returns raw completions. Prisma native GGUF runs the same weights through codeapp-server — decoding, parsing, and inference are part of the stack, not a layer bolted on afterward.
Bare llama-server GGUF
Gemma 4 E4B · stock path
Inference
Token generation only
Raw completion stream
Steps in stack
1
Task accuracy
5/6
Usable as-is
No
Prisma native GGUF
Gemma 4 E4B · codeapp-server
Decoding
GGUF → tensors
Parsing
Structure & validate
Inference
Generate & format
Formatted, verified completion
Steps in stack
3
Task accuracy
6/6
Usable as-is
Yes
Per-step industry averages
Typical E4B local stacks — decoding, parsing, and inference as separate tooling
Prisma native measured · industry figures representative · decoding and parsing stay under 1 ms final and ~5 ms streaming on average
Decoding
GGUF → tensors
Industry: Separate load hop per request
Prisma: Under 1 ms final · ~5 ms streaming average; fused in native pipeline
Parsing
Structure & validate
Industry: Post-inference processor
Prisma: Under 1 ms final · ~5 ms streaming average; inline during generation
Inference
Generate & format
Industry: Raw tokens only
Prisma: Verified output inline
Industry inference effective to 100%: 806 ms (Incl. retry + re-parse to 6/6) — plus separate decode (115 ms) and parse (78 ms) hops. Prisma runs all three in one pass at 931 ms total (10 ms decode+parse streaming · <2 ms final + 929 ms inference).
Prisma native — decode & parse throughput
Measured stage totals on Gemma 4 E4B · equivalent token processing rates
| Stage | Time spent | Equivalent rate |
|---|---|---|
| Decoding (token→UTF-8) | 4.3 ms total | ~19,000 tok/s |
| Parsing (final pass) | 2.2 ms total | ~37,800 tok/s |
| Parsing (streaming pass) | 28.1 ms total | ~2,900 tok/s |
Per request (decode / parse final)
Prisma native decode and parse final pass rates across benchmark prompts
| Prompt | Tokens | Decode | Parse (final) |
|---|---|---|---|
| math-multiply | 9 | ~52,500 tok/s | ~26,000 tok/s |
| capital-france | 7 | ~12,200 tok/s | ~21,000 tok/s |
| logic-cats | 7 | ~121,300 tok/s | ~21,900 tok/s |
| python-add | 25 | ~69,100 tok/s | ~50,600 tok/s |
| json-alice | 20 | ~20,900 tok/s | ~57,800 tok/s |
| reverse-string | 14 | ~6,400 tok/s | ~42,300 tok/s |
Single pass vs industry standard
Wall-clock time to a verified, formatted completion
Industry · 3 separate passes
805 ms
83% accuracy · raw output
Industry · to 100% verified
1039 ms
Retries + re-parse across hops
Prisma native · single pass
931 ms
100% accuracy · decode+parse <2 ms final
Prisma native · streaming overhead
939 ms
~10 ms decode+parse · 929 ms inference
Industry stacks chain decoding, parsing, and inference as three separate passes — 805 ms minimum, still only 83% accurate. Matching Prisma's 100% requires retries and re-parsing, pushing the industry path to ~1039 ms. Prisma native GGUF finishes all three steps in one pass at 931 ms (decode+parse under 1 ms final, ~10 ms streaming) — 10% greater performance than the industry path to the same guarantee, with no external tooling.
What is a raw token?
Why bare llama-server's first token isn't the same as a finished answer
A raw token is a single sampler output from the model — an unprocessed chunk of the completion stream. Bare llama-server forwards these as they are generated: no stop-string handling, no structure check, no guarantee the stream forms a complete or correct answer.
How raw tokens are typically used
- ·Stream to UI — append each token to a buffer and render character-by-character as it arrives.
- ·Wait for stream end — hold the full raw completion, then try to parse it as JSON, code, or plain text yourself.
- ·Retry on failure — if the stream is empty, truncated, or invalid (as on
logic-cats), run inference again and hope the next pass works.
Example · bare raw stream
Token 1 @ 273 ms: "The"
Token 2 @ +12 ms: " answer"
Stream end @ 582 ms: "" (empty on logic-cats)
Usable in IDE? Not until you parse, validate, and possibly retry — +78 ms minimum.
Prisma native returns the entire final result — decoded, parsed, and inferred in one pass. The first token at 346 ms is already formatted. The complete, verified answer arrives at 931 ms: nearly the same wall-clock as bare llama takes to reach a usable outcome once you account for external parsing and retries.
Bare · first raw token
Arrives fast — not yet usable
Bare · stream complete
Raw completion — may be empty or invalid
Bare · usable attempt
+78 ms external parse/validate
Bare · verified (industry path)
Retries + re-parse to match 6/6
Prisma · entire final result
Formatted, verified, IDE-ready — single pass
logic-cats, unstructured elsewhere. Industry averages 805 ms across three separate hops and still only reaches 83% accuracy. Prisma native integrates decoding, parsing, and inference in one pass at 931 ms — decoding and parsing stay under 1 ms final and ~5 ms streaming on average — 100% task accuracy, no retries, no post-processing. Faster to a correct, usable result than the industry standard path to the same guarantee.