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 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.
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.
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.
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 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.
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.
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.
--versionLog 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.
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.
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.
later run, after the handoff
11.629× slower
50.877× slower
576.618× slower
887.884× slower
1,954.702× slower
| 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 |
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.
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.
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 |
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 |
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 in the results directory. The npm handoff run is summary.json in the later results directory.
| 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) |
| Aider | aider-chat 0.86.2 |