# Benchmarks

bwn starts in 0.557 ms, about half a millisecond. That is 11.629× faster than Claude Code, the next agent CLI in this run.

Measured on 15 November 2026 on a 4-core Intel Xeon under KVM, Ubuntu 24.04, twenty warm hyperfine runs. Methodology.

A native install never starts Node. The first npm `bwn` copies the native binary and starts Node to do that. Later runs start the copy directly, and the npm times on this page are those later runs. [Install](https://buildwithnexus.dev/docs/install).

## What this measures

These are timings of a process on one computer: an Intel Xeon with 4 CPUs and 16780623872 bytes of RAM, Ubuntu 24.04.5 LTS, kernel 6.12.113+, under KVM, on 15 November 2026. They are not a score for answer quality, and they are not how fast a model writes tokens. `--version` measures the overhead of starting the program and getting back out.

### Startup

The timer starts when the operating system creates the process and stops when that process exits. hyperfine is run with `--shell=none`, so a shell is not inside the number. For the native binary, `--version` parses the arguments, prints one line, and exits. Along the way it marks extra inherited file descriptors close-on-exec and, if a provider key is in the environment, blanks that key. It does not read settings, open the full-screen interface, or open a network connection. `--help` is the same timer with the usage text instead of one line.

Warm is 3 untimed runs and then 20 timed runs, with the program already in the kernel's page cache. The chart is the median of those 20, which is the 50th percentile. The table also shows the mean and the standard deviation. This run does not publish a 95th percentile. Every sample is in the raw JSON. Cold is 20 runs, and each run first syncs and drops the page cache, so the executable is read from disk. Cold is not a reboot and it is not a first install.

Not included: a network round trip, model latency, or the first-run download. The npm row is after the handoff copy, so it does not include Node starting or the copy. The earlier launcher, which did start Node, was 21.236 ms. That figure is only in the methodology.

This is the delay before a command, a hook, or a script call can respond.

### Memory

Peak resident set size from `/usr/bin/time -v`, the "Maximum resident set size" field, median of 5 runs of `--version`. It is the top-level process only, in kibibytes. When the command is a Node launcher, the figure is that Node process, not a child binary. After the handoff the npm command's figure is the native binary.

This is the memory the command holds just to start.

### Install and download

Install bytes are the installed tree on disk. Download bytes are the files that run fetched: npm tarballs, the GitHub release asset, or pip wheels. The native row is one file, the release binary. Aider's own wheel is smaller than that binary; that comparison is in reading the numbers.

Download is what you wait for on the network. Install is what stays on disk.

### Ready prompt

Five runs in an 80 by 24 terminal. The timer starts at process start and stops when the transcript contains that tool's ready text. The process is still running, and it is killed after the match. bwn is given a settings file so setup does not run, and the text it waits for is the footer `permission:`. No model is called. Claude Code's first screen is a theme picker, and Gemini CLI waits on authentication, so those two are not timed.

This is how long until you can type.

### Mock task

Five runs against a local server that answers every request with the fixed text `BENCHMARK_OK`. The timer is wall-clock time until the process exits 0 and that text is in the output. The server does no model work. The time includes startup plus that local request. Claude Code and Gemini CLI cannot be pointed at that server, so they have no task time.

This is a fixed local job with the model taken out. It compares the tools, not a hosted model.

## Warm `--version`

Log scale. Each bar is log10 of that median divided by bwn (native), as a fraction of the slowest tool. A 1× result has no log length, so that bar is drawn at a fixed minimum and the measured median is printed beside it. bwn (npm) is a later run and is not slower, so its bar matches native.

bwn (native)0.557 ms

bwn (npm)0.535 ms

Claude Code6.472 ms11.629× slower

Codex CLI28.316 ms50.877× slower

OpenCode320.927 ms576.618× slower

Aider494.168 ms887.884× slower

Gemini CLI1087.925 ms1,954.702× slower

The first npm `bwn` copies the native binary onto that command. Later runs start the copy and do not start Node. A native install never starts Node. [Install](https://buildwithnexus.dev/docs/install).

## Medians

Warm and cold `--version` and `--help`, peak resident set size, and the bytes installed and downloaded. The npm row is the later handoff run. The other rows are the first run.

### bwn (native)

- **Mean (ms)**: 0.639
- **Median (ms)**: 0.557
- **Stddev (ms)**: 0.137
- **Version cold (ms)**: 4.872
- **Help warm (ms)**: 0.604
- **Help cold (ms)**: 3.568
- **RSS (KiB)**: 3456
- **Install (bytes)**: 6492376
- **Download (bytes)**: 6492376

### bwn (npm)

later run, after the handoff

- **Mean (ms)**: 0.580
- **Median (ms)**: 0.535
- **Stddev (ms)**: 0.104
- **Version cold (ms)**: 5.546
- **Help warm (ms)**: 0.570
- **Help cold (ms)**: 5.988
- **RSS (KiB)**: 3464
- **Install (bytes)**: 6643749
- **Download (bytes)**: 6547655

### Claude Code

11.629× slower

- **Mean (ms)**: 6.545
- **Median (ms)**: 6.472
- **Stddev (ms)**: 0.516
- **Version cold (ms)**: 42.675
- **Help warm (ms)**: 87.418
- **Help cold (ms)**: 156.073
- **RSS (KiB)**: 22984
- **Install (bytes)**: 731894792
- **Download (bytes)**: 169382845

### Codex CLI

50.877× slower

- **Mean (ms)**: 28.212
- **Median (ms)**: 28.316
- **Stddev (ms)**: 1.154
- **Version cold (ms)**: 54.505
- **Help warm (ms)**: 28.006
- **Help cold (ms)**: 53.241
- **RSS (KiB)**: 52884
- **Install (bytes)**: 422680010
- **Download (bytes)**: 167006502

### OpenCode

576.618× slower

- **Mean (ms)**: 319.574
- **Median (ms)**: 320.927
- **Stddev (ms)**: 3.288
- **Version cold (ms)**: 385.681
- **Help warm (ms)**: 329.386
- **Help cold (ms)**: 396.939
- **RSS (KiB)**: 130804
- **Install (bytes)**: 643168267
- **Download (bytes)**: 158275448

### Aider

887.884× slower

- **Mean (ms)**: 493.762
- **Median (ms)**: 494.168
- **Stddev (ms)**: 7.232
- **Version cold (ms)**: 691.103
- **Help warm (ms)**: 495.428
- **Help cold (ms)**: 748.209
- **RSS (KiB)**: 73488
- **Install (bytes)**: 645560252
- **Download (bytes)**: 125519775

### Gemini CLI

1,954.702× slower

- **Mean (ms)**: 1092.928
- **Median (ms)**: 1087.925
- **Stddev (ms)**: 20.422
- **Version cold (ms)**: 1099.182
- **Help warm (ms)**: 1073.645
- **Help cold (ms)**: 1098.592
- **RSS (KiB)**: 214972
- **Install (bytes)**: 102977281
- **Download (bytes)**: 21942165

| Tool | Mean (ms) | Median (ms) | Stddev (ms) |
| --- | --- | --- | --- |
| bwn (native) | 0.639 | 0.557 | 0.137 |
| bwn (npm) | 0.580 | 0.535 | 0.104 |
| Claude Code | 6.545 | 6.472 | 0.516 |
| Codex CLI | 28.212 | 28.316 | 1.154 |
| OpenCode | 319.574 | 320.927 | 3.288 |
| Aider | 493.762 | 494.168 | 7.232 |
| Gemini CLI | 1092.928 | 1087.925 | 20.422 |

| Tool | Version warm (ms) | Version cold (ms) | Help warm (ms) | Help cold (ms) | RSS (KiB) | Install (bytes) | Download (bytes) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| bwn (native) | 0.557 | 4.872 | 0.604 | 3.568 | 3456 | 6492376 | 6492376 |
| bwn (npm) | 0.535 | 5.546 | 0.570 | 5.988 | 3464 | 6643749 | 6547655 |
| Claude Code | 6.472 | 42.675 | 87.418 | 156.073 | 22984 | 731894792 | 169382845 |
| Codex CLI | 28.316 | 54.505 | 28.006 | 53.241 | 52884 | 422680010 | 167006502 |
| OpenCode | 320.927 | 385.681 | 329.386 | 396.939 | 130804 | 643168267 | 158275448 |
| Aider | 494.168 | 691.103 | 495.428 | 748.209 | 73488 | 645560252 | 125519775 |
| Gemini CLI | 1087.925 | 1099.182 | 1073.645 | 1098.592 | 214972 | 102977281 | 21942165 |

## Why it's fast

The 0.557 ms warm `--version` is one native executable, built from Rust. That process does not start Node, Python, or a JIT, and it does not load a module graph. The code that prints the version is already in the file. It parses the arguments, prints one line, and exits.

Settings are read when a command needs them. `--version` does not read them. The full-screen interface starts for an interactive session, not for `--version`. The HTTP client used for model requests is created on the first request and then kept, not while the process is starting.

The release binary is 6492376 bytes. The other native binaries in this run are larger: OpenCode 214386864, Codex CLI 294277432, Claude Code 365842960. Cold `--version`, which reads the file from disk, was 4.872 ms for the native binary and 42.675 ms for Claude Code. Gemini CLI and Aider start as scripts, so their timer includes an interpreter.

After the handoff, npm `bwn` is that same binary. The first run copies it and points the command at the copy. The later runs measured here were 0.535 ms warm `--version` and 3464 KiB peak resident set, next to 0.557 ms and 3456 KiB for invoking the binary directly. Before the handoff the npm command started Node and took 21.236 ms, with a peak resident set of 45840 KiB.

## Reading the numbers

In the first run the native binary was first on startup, memory, install size, download size, the ready prompt, and the mock task, among the tools measured together. Aider's package file is smaller: 377,009 bytes, against the 6,492,376 byte release binary.

A later run on the same machine measured npm `bwn` after the handoff. Warm `--version` was 0.535 ms (mean 0.580, standard deviation 0.104), and peak RSS was 3,464 KiB. The native binary in that same run was 0.588 ms. The first npm run copies the binary; these times are the later runs.

bwn (native) and the npm command after the handoff run the same release ELF, 6492376 bytes. OpenCode, Codex CLI and Claude Code also ship native binaries, of 214386864, 294277432 and 365842960 bytes. Gemini CLI and Aider are scripts (5152 and 259 bytes) and are not native binaries.

## Ready prompt

Median seconds until a prompt is ready, from 5 runs in a PTY. Claude Code stops on a theme picker. Gemini CLI waits on authentication. The npm figure is the later handoff run.

| Tool | Median (s) |
| --- | --- |
| bwn (native) | 0.250 |
| Claude Code | not measured |
| bwn (npm) | 0.250 |
| Codex CLI | 0.284 |
| OpenCode | 2.586 |
| Aider | 0.609 |
| Gemini CLI | not measured |

## Mock task

Median seconds for one local task, from 5 runs. Claude Code speaks Anthropic Messages, not an OpenAI-compatible endpoint. Gemini CLI's base URL is the Gemini API. The npm figure is the later handoff run.

| Tool | Median (s) |
| --- | --- |
| bwn (native) | 0.058 |
| Claude Code | not measured |
| bwn (npm) | 0.058 |
| Codex CLI | 0.246 |
| OpenCode | 1.441 |
| Aider | 2.210 |
| Gemini CLI | not measured |

## Methodology

Measured on 15 November 2026 on an Intel Xeon with 4 CPUs and 16780623872 bytes of RAM, running Ubuntu 24.04.5 LTS, kernel 6.12.113+, under KVM. hyperfine 1.18.0, Node v22.23.4 and Python 3.12.3. Each tool had its own HOME.

Startup is hyperfine with `--shell=none`. A warm result is 20 runs after 3 warmup runs. A cold result is 20 runs, and each run is prepared with `sync` and `drop_caches`. The milliseconds on this page are hyperfine's seconds rounded to 3 decimals. Mean, median and standard deviation are hyperfine's. The median is the 50th percentile of those 20 runs. A 95th percentile is not published.

Claude Code's warm `--version` median, 0.006472312 s, divided by bwn native's 0.000556568 s, is 11.628968966954623. The chart labels that 11.629×. The other multiples are the same division, labeled to 3 decimals. Bar length is log10 of that multiple, divided by log10 of 1954.702283458625 (Gemini CLI). A multiple of 1 has no log length, so that bar is drawn at a fixed minimum. The milliseconds beside every bar are the measured medians.

The npm row is a later run of the same method on the same machine, after the launcher copies the native binary and points `bwn` at it. The timed runs are after that copy. In that run the native binary's warm `--version` median was 0.0005880835 s (0.588 ms) and the npm command's was 0.000534615 s (0.535 ms). The npm command in the first run, before the handoff, was 21.236 ms. That earlier figure is not a row here.

Peak RSS is the median of 5 runs of `/usr/bin/time -v` on `--version`, for the top-level process, in KiB. After the handoff that process is the native binary. Install bytes are the installed tree. Download bytes are the files that run fetched.

The mock task uses a local OpenAI-compatible server so model latency is the same canned reply, `BENCHMARK_OK`. Claude Code was skipped because it speaks Anthropic Messages, not an OpenAI-compatible endpoint. Gemini CLI was skipped because its base URL is the Gemini API.

The first run is [summary.json](https://github.com/Garretts-Apps/buildwithnexus/blob/main/bench/results/2026-11-15T16-29-28Z/summary.json) in the [results directory](https://github.com/Garretts-Apps/buildwithnexus/tree/main/bench/results/2026-11-15T16-29-28Z). The npm handoff run is [summary.json](https://github.com/Garretts-Apps/buildwithnexus/blob/main/bench/results/2026-11-15T17-29-49Z/summary.json) in the [later results directory](https://github.com/Garretts-Apps/buildwithnexus/tree/main/bench/results/2026-11-15T17-29-49Z).

### Versions

| Tool | Version |
| --- | --- |
| bwn (native) | buildwithnexus 0.21.0 |
| bwn (npm) | buildwithnexus 0.21.0 |
| Claude Code | 2.1.325 |
| Codex CLI | 0.169.0 |
| Gemini CLI | 0.68.0 |
| OpenCode | 1.19.5 (package opencode-ai, repository [sst/opencode](https://github.com/sst/opencode)) |
| Aider | aider-chat 0.86.2 |

[Next: Changelog →](https://buildwithnexus.dev/docs/changelog)

MIT licensed · Made by [Garrett Eaglin](https://garretteaglin.com/)
