---
license: apache-2.0
pretty_name: CapyCTL bench results
language:
- en
tags:
- benchmark
- llm-inference
- inference-engines
- vllm
- sglang
- llama.cpp
- tensorfold
- capyctl
size_categories:
- 10K<n<100K
configs:
- config_name: points
  default: true
  data_files: data/points.parquet
- config_name: entries
  data_files: data/entries.parquet
---

# CapyCTL bench results

Every point measured by [capyctl-bench](https://github.com/edurdias/capyctl-recipes/tree/main/tools/capyctl-bench)
for the 38 recipes and 12 comparisons in
[capyctl-recipes](https://github.com/edurdias/capyctl-recipes), in one table: decode speed, time to first token,
prompt processing and memory against prompt length and concurrent streams for chat models, and latency, throughput,
calibration and accuracy for decision models. vLLM, SGLang, TensorFold, llama.cpp and a custom engine, on an NVIDIA GB10,
an RTX 4090 Laptop GPU and two RTX A6000 cards.

Every request went through [CapyCTL](https://github.com/edurdias/capyctl)'s inference endpoint, not to the engine
directly. Built from capyctl-recipes at
[`1829ae0`](https://github.com/edurdias/capyctl-recipes/commit/1829ae0b0e6c4731016965eafdeea0ee0bc2a225). The reports themselves, with their charts,
are in the [benchmarks Space](https://huggingface.co/spaces/capyctl/benchmarks).

```python
from datasets import load_dataset

points = load_dataset("capyctl/bench-results", "points", split="train")
entries = load_dataset("capyctl/bench-results", "entries", split="train")
```

## Configs

### `points` (11,268 rows)

The `data.csv` of each of the 53 capyctl-bench reports, stacked, with the recipe or comparison it belongs to.

| Column | Meaning |
|---|---|
| `entry` | The recipe or comparison directory, such as `vllm/gpt-oss-120b-gb10`. Joins to `entries`. |
| `report` | The report's directory inside `entry`: `bench` for the main one, others for extra studies (`bench/overhead`, `bench-sweetspot`). |
| `kind` | `recipe` or `comparison`. |
| `report_title` | The report's title. |
| `series` | One results file: an engine, version and setting. Compare series only within one report. |
| `section` | `context` (one stream, prompt length growing), `concurrency` (streams or users), `latency`, `cache`, `accuracy` and `reliability` (decision models). |
| `point`, `x` | The point on the x axis: a prompt size such as `32k`, a stream count, a question count and state size, or a quality set. |
| `metric`, `unit` | What was measured, such as `decode_tps` in `tok/s` or `ttft_p50_s` in `s`. |
| `median`, `min`, `max`, `n` | The median over `n` samples and its range. Empty where nothing was measured (`n` 0). |

The chat metrics:

| Metric | Definition |
|---|---|
| `ttft_s`, `ttft_p50_s`, `ttft_p95_s` | Request sent to the first token chunk. |
| `decode_tps` | (completion tokens - 1) / (last token chunk - first token chunk): the decode rate one stream sees, drafts included. |
| `tpot_ms` | The inverse of `decode_tps`. |
| `prompt_tps` | Prompt tokens / time to first token. Includes queueing and the first decode step, so it understates raw prefill at short prompts. |
| `total_s` | Request sent to the end of the stream. |
| `output_bytes_per_s`, `output_chars_per_s` | Content and reasoning over the generation window; compares engines whose tokenizers differ. |
| `aggregate_tps` | Concurrency: a round's completion tokens / (first request sent to last stream finished), median over rounds. |
| `per_stream_tps` | Concurrency: median `decode_tps` over every request at that stream count. |
| `draft_acceptance` | Accepted / drafted tokens, when the engine reports draft counts. |
| `memory_peak_gib` | The highest memory sample taken while the request or round ran (machine RAM in use on unified memory). |

The decision-model metrics (latency, `requests_per_s`, `questions_per_s`, `accuracy`, `macro_f1`, `brier`, `nll`, `ece`,
`kl`, and the reliability bins) are defined in
[Measure a decision model](https://github.com/edurdias/capyctl-recipes/tree/main/tools/capyctl-bench#measure-a-decision-model).

### `entries` (50 rows)

One row per recipe or comparison, from the tables of the capyctl-recipes README: `engine`, `model`, `hardware`, the
headline `result`, the date it was `measured`, the number of `reports`, the GitHub `url` and the main `report_url`.
The native TP2 and concurrency comparisons used their own harness, so they have no rows in `points`; their evidence is
on GitHub.

## Reading the numbers

- Compare series within one report. A report puts series side by side only when they ran on the same machine with the
  same prompts and settings; across reports, prompts, settings, CapyCTL and engine versions can differ.
- Each recipe's README names the exact CapyCTL, engine, model and drafter revisions, the deployment file and the
  settings. Read it before quoting a number.
- One machine per result, on the date given. These are measurements, not a qualification of an engine on your
  hardware.
- Each recipe states its thinking setting and sampling parameters. Reasoning tokens count as output tokens, and many
  runs cap replies with `max_tokens`.

## License

Apache-2.0, as capyctl-recipes. The model names refer to their own repositories and licenses.