Pi vs Pi-Bolt: CPU, RAM and Completion Time on a 4-vCPU VPS

I’ve been running Pi as my coding agent harness on a small VPS for a while now. Then Pi-Bolt showed up: a fork of Pi that compiles the whole thing ahead of time into one native executable. Same Pi, same commands, same sessions and extensions, just no Node.js or JIT at launch.

The project makes some big claims about CPU and memory, so I wanted to see what it looks like on my own box, with a real (if tiny) coding task. I ran Pi and Pi-Bolt on the same task, with the same model, thinking level and user prompt. The agents ran sequentially, not concurrently.

Updated 25 October 2026: I reran the benchmark with three fresh sessions per agent: all three Pi runs first, then all three Pi-Bolt runs. Pi stayed at 1.4.0; the installed Pi-Bolt is now 1.0.3, not the 1.0.0 used in the original test. The results below replace the original single-run numbers rather than pooling different versions. All six runs are included, including one output-formatting mismatch.

Quick answer: is Pi-Bolt lighter than Pi?

#

Across three runs each, Pi-Bolt used 78.9% less median local CPU time and 36.8% less median peak RAM than Pi. Median completion time was 30.8% lower, but API variability makes that a much weaker result.

All six scripts calculated the correct sum and printed three blank-line-separated paragraphs. One Pi-Bolt run inserted extra line breaks inside the first and third paragraphs, so its output did not match the requested text exactly.

These are exploratory results, not a statistically rigorous benchmark. Three runs each, on one VPS, with a fixed execution order. The limitations are spelled out further down.

What is Pi-Bolt?

#

Pi-Bolt is an independent fork of the Pi coding agent, forked at Pi’s v1.4.0 tag and compiled ahead of time (AOT) to native code. It is not affiliated with Pi’s authors. Instead of parsing and JIT-compiling JavaScript every time it starts, every function is compiled to machine code when the executable is built. It ships as one binary for Linux x86-64 and ARM64 (including Android in Termux), macOS on Apple silicon and Windows x64, and it does not need Node.js or Bun installed.¹

It installs next to Pi as pi-bolt, so both can stay installed, and it reads your existing Pi configuration in ~/.pi/agent as is. That made it easy to compare the two side by side on the same machine.

The project’s own benchmarks claim much bigger numbers than mine (for example 7.1x less CPU over an interactive session and 4.5x less memory after 40 prompts), but those measure longer sessions and streaming.¹ My test is a short, one-shot task, which is a different and much smaller workload.

Server specifications

#

Both agents ran on the same KVM virtual machine:

The CPU model is what the VM exposes; this was not a dedicated 32-core machine. The benchmark had four virtual CPUs available.

Some swap was occupied when the server specifications were collected afterward. Swap activity and other background server activity were not monitored during the benchmark.

Software versions

#

Pi-Bolt 1.0.3 reports Pi 1.4.0 underneath, so both agents used the same underlying Pi release. This rerun used the installed Linux x64 build, which reported that JIT was disabled. I did not upgrade either agent for the test.

The generated JavaScript programs were executed with the same system Node.js installation.

Model tested

#

The comparison used:

• Provider: openai-codex
• Model: gpt-6-luna
• Thinking level: high

Both agents used the same provider, model ID and requested thinking level.

The task

#

Each agent had to create a standalone task.mjs file that:

1. Calculates the sum of squares from 1 through 1,000,000, inclusive.
2. Uses a BigInt loop, not a closed-form formula.
3. Prints exactly three Lorem Ipsum paragraphs.
4. Inserts the calculated result into the middle paragraph.
5. Runs the script to verify it.
6. Finishes with a short confirmation.

The exact user prompt was:

Create task.mjs in the current directory using only Node.js built-ins. Calculate the sum of squares of all integers from 1 through 1000000 inclusive using a BigInt loop (not a closed-form formula). Print exactly three paragraphs separated by a blank line. Each paragraph uses this exact text: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
In the second paragraph, insert the calculated value halfway through, between the first sentence and 'Sed', formatted as Result: <value>. Do not put the result in either other paragraph. Run node task.mjs once to verify it. Do not create any other files. Finish with only Done.

Both agents generated this calculation:

let sum = 0n;

for (let i = 1n; i <= 1000000n; i++) {
  sum += i * i;
}

The surrounding string construction differed slightly. Five scripts printed identical output; one differed only in internal line breaks, as detailed below.

Test procedure

#

The execution order was:

1. Pi, runs 1, 2 and 3
2. Pi-Bolt, runs 1, 2 and 3

Each of the six runs used a separate, empty working directory with a fresh, non-persisted session. There were no discarded attempts, replacement runs or separate warm-ups. Verification ran after each agent exited, outside its measured interval. This fixed block order follows the requested procedure; it does not control for cache or provider-side order effects.

To reduce unrelated configuration overhead, the runs disabled:

• Extensions
• MCP connections
• Skills
• Context-file discovery
• Prompt templates
• Themes
• Automatic startup network operations

Both agents had the same four tools enabled:

read,bash,edit,write

The CLI invocation followed this pattern:

pi \
  --provider openai-codex \
  --model gpt-6-luna \
  --thinking high \
  --print \
  --mode json \
  --no-session \
  --no-extensions \
  --no-mcp \
  --no-skills \
  --no-context-files \
  --no-prompt-templates \
  --no-themes \
  --offline \
  --tools read,bash,edit,write \
  "$PROMPT"

The second run used the same arguments with pi-bolt instead of pi.

Despite the flag’s name, --offline disables automatic startup network operations; it does not prevent the requested model API calls.

All six runs followed the same tool sequence: write the file, execute it with Bash, then return a final response. Each agent exited successfully.

How resource usage was measured

#

A Python runner launched each CLI and collected its resource usage using Linux os.wait4().

CPU time

#

CPU time is the sum of:

user CPU time + system CPU time

This measures local CPU consumption, not the remote infrastructure running the language model. The accounting includes waited-for child-process usage reported by the OS.

Average CPU utilization

#

Average CPU utilization was calculated as:

CPU time / elapsed wall time × 100

Here, 100% means one fully utilized CPU core, not the entire four-vCPU server.

Peak RAM

#

Memory is the OS-reported peak resident set size, converted from KiB to MiB.

It is not a sum of every process’s simultaneously resident memory, and it does not represent remote model memory usage.

Completion time

#

Wall-clock time was measured from launching the CLI until it exited. It includes:

• CLI startup
• Model/API waiting
• Tool execution
• Running the generated script
• Final response and shutdown

The runner then independently executed each generated script to check its output. That extra verification was outside the measured agent completion time.

Results

#

Every measured run

#

Median summary

#

Each median is calculated independently from that metric’s three unrounded measurements. Percentage reductions use those unrounded medians, not the rounded table values. All three Pi-Bolt runs, including the formatting mismatch, remain in the summary.

Pi-Bolt used about 21.1% as much median CPU time and 45.63 MiB less median peak RAM. Every Pi-Bolt run used less CPU and peak RAM than every Pi run in this small sample.

Completion time was much noisier: Pi ranged from 10.203 to 15.980 seconds, and Pi-Bolt from 5.131 to 11.989 seconds. Those ranges overlap. The median difference was about 3.338 seconds, but I would not turn that into a general speed claim about the harness.

Output correctness

#

All six scripts used a BigInt loop and printed the correct result:

333333833333500000

Five of the six scripts produced this exact output:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Result: 333333833333500000 Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.

Independent verification confirmed three blank-line-separated paragraphs, the correct result in the second paragraph, and no result marker in the first or third for all six scripts.

Pi-Bolt run 2 failed the stricter, byte-for-byte output check. It used a single newline instead of a space between the two sentences in the first and third paragraphs. The arithmetic and paragraph placement were correct, but the requested exact text was not. I kept the run rather than silently retrying or reporting six exact passes. This tiny sample does not establish a general correctness difference between the harnesses.

Important limitations

#

This test has several limitations:

• Only three runs per agent. The medians are descriptive, not statistically stable estimates. There are no confidence intervals.
• Fixed execution order. All three Pi runs came first, then all three Pi-Bolt runs. Filesystem caches, provider-side caching and other order effects were not controlled.
• Network and model latency affect completion time. The 3.338-second median difference cannot confidently be attributed to the harness alone.
• The user prompt matched, but the full requests were not identical. Agent-specific system prompts, generated code, token usage and provider-side cache behavior differed.
• High thinking does not guarantee equal reasoning work. Both requested the same setting, but model behavior varied.
• One exact-output failure. Pi-Bolt run 2 had an internal-line-break mismatch. Its timing is included, but six equally correct outputs cannot be claimed.
• Different Pi-Bolt version from the original article. This rerun uses 1.0.3, not 1.0.0, so changes from the original numbers cannot be attributed to repetition alone.
• This was a minimal CLI configuration. It does not measure interactive TUI performance or a typical setup with extensions and MCP servers.
• Peak RSS is not aggregate process-tree memory.
• Background load and swap activity were not controlled.
• This is an agent-task benchmark, not an isolated JavaScript arithmetic benchmark. Both generated programs ran under the same Node.js runtime.

A stronger follow-up would repeat the task many times, alternate execution order, record background load, and report median and percentile results. A separate no-model startup benchmark would help isolate runtime overhead from API variability.

FAQ

#

Is Pi-Bolt a different coding agent from Pi?

#

No. Pi-Bolt is Pi compiled ahead of time into a native executable. It keeps the same commands, sessions, settings, providers and extensions, and this build reported itself as Pi 1.4.0 underneath.¹

Does Pi-Bolt make the model respond faster?

#

This test does not show that. The model runs on the provider’s servers. Median local CPU time dropped by 78.9%, while median end-to-end time dropped by 30.8%, but completion times varied widely and the ranges overlapped. I cannot separate API waiting, model behavior and harness overhead from these six runs.

Who benefits most from Pi-Bolt?

#

Anyone running Pi on small machines: cheap VPSes like mine, ARM boards, Termux on Android, or a laptop where you would rather keep CPU and battery for other things. Less local CPU and RAM per agent also helps if you run several agents at once.

Do I need Node.js to run Pi-Bolt?

#

No, Pi-Bolt itself runs without Node.js or Bun.¹ In this test I still used the system Node.js, but only because the task asked the agent to write and run a .mjs script.

Conclusion

#

For this small coding task, Pi-Bolt showed substantially lower local CPU consumption and a lower peak memory footprint in all three runs. The median reductions were 78.9% for CPU time and 36.8% for peak RAM.

Median completion time was 7.504 seconds versus 10.842 seconds, but the noisy, overlapping ranges make that a much less convincing harness-performance result. All six scripts got the arithmetic right; only five matched the requested output exactly.

The takeaway is still promising but narrow: Pi-Bolt was lighter locally in this sample. I would want more repetitions, alternating execution order and controlled output before treating the elapsed-time difference as a reliable advantage. On a 4 GB VPS though, the lower footprint is the part I care about most.