Historical evidence from September 19–20, 2026, preserved with its original results. Sys1 0.9 removes the CUA and Needle adapters and selects Qwen3 1.7B locally. See the current Jev and Qwen evaluation.
Local run September 19 · Hosted Jev run September 20, 2026 · Upstream sources checked September 19
Start with the job.
Sys1 supplies routing and a validated contract. The model supplies the judgment. Smaller files, faster answers, and better decisions are separate properties.
Scroll tables sideways on smaller screens to see all columns.
New native process per request. Sys1 maps decisions into an extraction tool. Explicit pin required.
Qwen3 0.6BQ4_0 GGUF
Compact local experiment
364.45 MiB
llama.cpp via node-llama-cpp. Scores the first-token distribution; 2,048-token configured context.
Qwen3 1.7BQ4_K_M GGUF
Local evaluation candidate
1,056.11 MiB
Same Sys1 adapter as 0.6B. Evaluate your task before trading memory for model size.
JevHosted TypeSafe service
Hosted typed decisions and probabilities
No local weights
Opt in with your credentials. State shared across parallel questions; provider bills input tokens.
OpenJevrazorback16/openjev
Your own compatible GPU server
Operator-managed
DiffusionGemma 26B-A4B via vLLM. Register an HTTP backend; Sys1 uses its common decision contract.
MiB = 1,048,576 bytes. File sizes are verified download footprints, not RAM requirements. Sys1 caches one local model by default; that limits model count, not memory bytes. Registry & artifact pins.
Measured through Sys1.
The same 20 public, synthetic form questions, sent through four local adapters and hosted Jev. Each asks for one of three actions. The results show which routes handled this small task, and where they fell short.
Apple M5 Max · 36 GiB system memory · macOS / Darwin 25.5.0 · Bun 1.3.14. The native capability probe selected Metal; per-inference GPU usage was not instrumented. Local adapters ran on this shared development machine on September 19; hosted Jev ran from the same host on September 20, 2026. These are separate snapshots.
The timing boundaries differ. Local latency measures the adapter and excludes HTTP. Jev latency includes the network round trip, provider processing, and complete response body. Neither is a controlled comparison of inference speed.
20 distinct labelled cases for correctness · 100 repeated calls per model for timing · concurrency 1
Model
Correct cases
p50 latency
p95 latency
Valid decisions
Valid responses
CUA-S1 FormsLocal adapter
8/20 (40%)
54.8 ms
60.7 ms
18.16/s
100/100
Cactus Needle 3Local adapter
8/20 (40%)
143.5 ms
171.3 ms
6.87/s
100/100
Qwen3 0.6BLocal adapter
8/20 (40%)
206.6 ms
225.1 ms
4.83/s
100/100
Qwen3 1.7BLocal adapter
18/20 (90%)
258.3 ms
271.4 ms
3.92/s
100/100
Jev 1.13.0Hosted HTTP round trip
20/20 (100%)
246.1 ms
343.0 ms
3.89/s
100/100
The smaller local routes are not reliable enough for this task. CUA, Needle, and Qwen 0.6B each reached 8/20, barely above the 7/20 majority-label baseline. Qwen 1.7B missed two cases; Jev answered all 20 correctly. Start an evaluation of similar decisions with Jev, or Qwen 1.7B when local execution is required. Twenty authored cases still do not qualify either for unattended production use.
These are whole-form narrative questions: submit, correct, or wait. CUA’s native training format uses individual TASK/FORM/ELEMENT observations and fill/check/click/skip actions. Its score here measures transfer to this request format, not native form-filling quality. Needle is also being adapted from extraction into a choice task.
Qwen and CUA reuse a resident model after two warmups. Needle starts a new process on every call. The latency boundary is the local adapter, including model work and IPC, excluding HTTP/gateway routing, downloads, and response validation. Throughput includes loop and validation overhead.
Repeating the same 20 cases five times gives 100 timing observations, not 100 independent quality examples. All 500 repeated calls across the five routes returned valid responses, with no errors or timeouts. A valid response can still be wrong. OpenJev was not measured.
Jev used the pinned jev-1.13.0 model with no retries: three initial client calls, two warmups, then 100 measured calls. Client region is unverified; provider hardware, load, and caching are unknown. One question per request does not test Jev’s shared-state, multi-question advantage.
What went wrong in the local routes
Qwen 0.6B and Needle selected “submit” on 19 of 20 cases and never selected “correct.” CUA selected “correct” on 15 of 20. These choices were stable across all five passes. This is systematic failure on the tested task, not occasional malformed output.
High confidence did not make the answers dependable: all 12 wrong Needle answers and 10 of 12 wrong Qwen 0.6B answers had confidence of at least 0.90. The fixture uses a fixed option order, so it cannot separate position bias from poor task understanding. Next checks need permuted options, fresh held-out cases, and each specialist’s native task format.
Among eligible local candidates, routing prefers the smallest model. With both Qwen tiers available, 0.6B is selected when policy chooses local execution. For application evaluation, explicitly pin the model you intend to test; do not treat automatic selection or an installation recommendation as quality approval. A broad migration of existing Jev applications is not supported by this evidence.
First-call timings and actual token counts
Three local fresh-runner or hosted initial-client calls · input usage across 100 repeated calls
Model
First calls, in run order
Reported input tokens
CUA-S1 Forms
79.9 / 66.3 / 61.6 ms
Not applicable (byte scorer)
Cactus Needle 3
303.5 / 136.7 / 143.1 ms
Not exposed by adapter
Qwen3 0.6B
1189.6 / 1093.4 / 1099.1 ms
12,960 total / 129.6 mean
Qwen3 1.7B
1625.4 / 1145.9 / 1110.0 ms
12,960 total / 129.6 mean
Jev 1.13.0
959.5 / 202.5 / 229.2 ms
34,760 total / 347.6 mean
Fresh runners are not cold-machine measurements: hash verification has already read the weights into OS file caches. No output text is returned by the Qwen scoring path. CUA and Needle report zero token counters with the different meanings explained below. Peak model RAM and GPU memory were not measured.
Jev’s first three client calls are sequential requests from one process, not cold server starts or independent connections. Across the 100 measured calls, Jev reported 34,760 input and 3,800 output tokens (347.6 input / 38 output per call). These counters describe the provider’s accounting, not a cross-model measure of compute.
At $0.042 per million input tokens with output free, the measured calls cost an estimated $0.00145992. All 105 calls, including initial calls and warmups, reported 36,510 input and 3,990 output tokens: $0.00153342 estimated total. These are usage-based estimates, not invoices. Price reconfirmed September 20, 2026.
Local source: 83ca299; Jev source: e770483. Both runs used the identical fixture, runtime source, and lockfile, with relevant files unmodified. Raw reports record full provenance. Local weights have verified hashes; Jev’s version is provider-reported. Percentiles use nearest rank. The reports preserve the original measurements without reranking or removing failed cases.
What the publishers report.
Useful context, with the hardware and workload attached. These results use different datasets and runtimes; their numbers do not form a shared leaderboard.
Jev: hosted decision latency
TypeSafe · September 15 launch report
70–500 ms end to end, generally from West Coast laptops to TypeSafe’s West Coast service. The published range does not specify a percentile or sample count.
TypeSafe’s separate four-workflow evaluation displays 67.8% reference agreement, about 0.4 seconds and $0.0004 per workflow case. These are rounded, equal-weight overview values. Agreement is with a frontier-model consensus, rather than human-labelled accuracy.
Three questions per request, cache-busted states, and upstream reporting “using 38% of the GPU.” This is a server-throughput result; input-token distribution, sample count, and accuracy are not supplied.
Upstream OpenJev benchmark
Concurrency
Requests/s
p50
p95
1
10.7
94 ms
94 ms
16
43.3
367 ms
369 ms
32
51.7
545 ms
618 ms
64
57.4
760 ms
1,109 ms
More concurrent traffic raises total throughput and the time each request waits. Pinned source & conditions.
Cactus Needle: edge inference
Needle 3 family · Raspberry Pi 5
400–4,000 decode tokens/s and 1,000–10,000 prefill tokens/s across the vendor’s model-depth range. Prefill reads the input; decode produces new tokens. The range is not an end-to-end measurement of Sys1’s pinned 121M model.
The separate 20-layer quality chart reports 86.0% exact calls on Mobile Actions (961 examples) and 47.0% exact ordered calls on DroidCall (200 examples), using the publisher’s CQ2 engine and confidence gate. The change across tasks matters more than one headline accuracy. Published quality chart.
Sequence lengths, repeat counts, and a per-depth speed mapping are not attached to the speed headline. Current upstream 8–29 MB size claims also differ from Sys1’s verified 33.70 MiB weight artifact.
Qwen’s official table reports 414.17 tokens/s for Qwen3 0.6B and 227.80 tokens/s for 1.7B: batch one, one input token, 2,048 generated tokens, SGLang 0.4.6.post1. Its formula includes input plus generated tokens.
Sys1 uses quantized GGUF weights and a first-token probability readout. A long-generation GPU benchmark cannot predict its local decision latency.
Related research in SemIf compares two output paths for the same Qwen3.5-4B BF16 model on an RTX 3090. For 21 binary questions, direct probability readout took a median 1.023 s with zero generated answer tokens; a generated JSON array took 5.332 s and 111 output tokens, over three runs.
The paths agreed on 18 of 21 decisions, so this demonstrates an output-path tradeoff rather than equivalent answer quality. SemIf was previously named TheoLeeCJ/openjev; it is separate from the OpenJev server above and is not a bundled Sys1 adapter. Pinned results.
Zero output tokens still takes work.
A classifier, a tool-calling model, and a text generator count work differently. Use completed decisions per second for a shared unit, then inspect what the token counters actually mean.
Qwen through Sys1
Reports the actual tokenized prompt count, summed across questions. Each question evaluates its own wrapped prompt, so repeating a large state can cost input processing time. Output usage is zero because Sys1 reads the first-token probability distribution instead of returning generated text.
CUA-S1 Forms
Scores UTF-8 byte representations directly. Generative tokens per second is not an applicable metric. The wire response uses zero token counters.
Cactus Needle
Performs native tool-call inference. Sys1 currently returns zero token counters because this adapter does not expose accounting. Read them as unreported, not as zero model work.
Hosted Jev
Reads shared state once and evaluates questions in parallel. In our 100-call run it reported 34,760 input and 3,800 output tokens; output is free at the published price. Token counts differ from Qwen because the models and request processing differ. Its documented account rate limits describe allowed traffic, not achieved inference speed. Current model & pricing.
Estimate Jev input cost.
Published price for Jev 1.13: $0.042 per million input tokens, with output free. Change request volume and average billed input tokens to estimate a monthly total.
Arithmetic only. Excludes retries and any future price changes. Local models have hardware, memory, energy, and operating costs instead of this API charge.
Use the provider’s usage counters, not JSON byte length.
Make the result useful for your app.
Start with labelled cases from your actual workflow. Pin the model, adapter, and hardware. Then measure the whole path your users will wait for.
Check correctness and failures. A valid answer shape can still contain a wrong decision. Keep wrong answers, timeouts, and unsupported requests visible.
Separate first call from steady use. Loading weights and starting processes can dominate a short request. OS file caching makes a fresh runner different from a cold machine.
Keep workload size explicit. Record state length, question count, options, concurrency, and context configuration. Report p50 and p95 latency with sample counts.
Evaluate confidence separately. A normalized probability or model-reported confidence is not evidence of calibration. Test thresholds against held-out labels before letting them authorize actions.
Sys1’s advantage is that you can run this comparison behind the same application contract, then choose a policy or an explicit model pin. Switching the interface does not establish interchangeable model quality.