buildwithnexusv0.21.0
Menu

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.

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.

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.

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
ToolMean (ms)Median (ms)Stddev (ms)
bwn (native)0.6390.5570.137
bwn (npm)0.5800.5350.104
Claude Code6.5456.4720.516
Codex CLI28.21228.3161.154
OpenCode319.574320.9273.288
Aider493.762494.1687.232
Gemini CLI1092.9281087.92520.422
ToolVersion warm (ms)Version cold (ms)Help warm (ms)Help cold (ms)RSS (KiB)Install (bytes)Download (bytes)
bwn (native)0.5574.8720.6043.568345664923766492376
bwn (npm)0.5355.5460.5705.988346466437496547655
Claude Code6.47242.67587.418156.07322984731894792169382845
Codex CLI28.31654.50528.00653.24152884422680010167006502
OpenCode320.927385.681329.386396.939130804643168267158275448
Aider494.168691.103495.428748.20973488645560252125519775
Gemini CLI1087.9251099.1821073.6451098.59221497210297728121942165

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.

ToolMedian (s)
bwn (native)0.250
Claude Codenot measured
bwn (npm)0.250
Codex CLI0.284
OpenCode2.586
Aider0.609
Gemini CLInot 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.

ToolMedian (s)
bwn (native)0.058
Claude Codenot measured
bwn (npm)0.058
Codex CLI0.246
OpenCode1.441
Aider2.210
Gemini CLInot 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 in the results directory. The npm handoff run is summary.json in the later results directory.

Versions

ToolVersion
bwn (native)buildwithnexus 0.21.0
bwn (npm)buildwithnexus 0.21.0
Claude Code2.1.325
Codex CLI0.169.0
Gemini CLI0.68.0
OpenCode1.19.5 (package opencode-ai, repository sst/opencode)
Aideraider-chat 0.86.2

Next: Changelog →