agentperf

agentperf

How fast is your computer for AI coding agents?
agentperf benchmarks the local work behind every tool call,
then tells you what is slowing it down.

Quick start · What you get · Reading your score · Commands · How it works

When Claude Code or Codex works on your code, the model does its thinking in the cloud. Everything else happens on your computer. A tool call might start a shell, read or edit files, search with ripgrep, run git, and pipe the output back. One task can make hundreds of these calls, so a few milliseconds per call add up quickly.

agentperf times that local work. It runs the same fixed tests on every machine, compares your results with a reference machine, and explains your score: which tests cost you points, what is probably causing it, and what to fix first.

It is one Python package with no dependencies. It runs on macOS, Linux, WSL2, and Windows with Python 3.8 or newer.

Quick start

pipx install agentperf
agentperf run --quick --html report.html

To install the latest code from GitHub instead, use pipx install git+https://github.com/SergeSerb2/agentperf.git.

A quick run takes a few minutes. When it finishes, open report.html and read Biggest wins first.

If you prefer not to install anything, download agentperf.pyz from the latest release and run it with Python:

python3 agentperf.pyz run --quick --html report.html

On Windows, type py instead of python3. In WSL, run agentperf inside the Linux distro, from a folder on the Linux filesystem (not under /mnt/c).

What you get

Every run gives you three numbers:

After the numbers, agentperf explains the score. This is an excerpt from the end of a run on a busy laptop (the full output also lists every test and a findings checklist):

AgentMark 408  (90% bootstrap over runs and samples 394-467, coverage 100%)  vs reference 'WSL2 - i7-12700K (reference, 1000)'
Reach     3,287  (network to model APIs and CDNs)
LW100     3.6 s estimated local wait per 100 tool calls (reference 1.0 s, same parts)

Why this score
  About 2-3x slower than the reference at local agent work. Agents wait on local tools more than they need to; some of the gap may be the OS and its tools. See the biggest wins.
  Biggest drag: process.parallel at x0.05 vs reference (about +73 AgentMark if it matched the reference).
  Biggest wins (each gain is an estimate if the affected tests reached reference speed; gains overlap):
  1. [possible] Process and file overhead (OS or security layer) (about +335 at reference speed)
     Fix: Rule out security software, indexing, and synced folders on code folders; what remains is the OS's own per-process cost.
  2. [observed] Background load during the run (gain not estimated)
     Fix: Quit or restart the busy processes (a daemon pinned near 100% for hours is a bug, not load).

The HTML report goes further. It places you next to the bundled reference machines, shows the evidence behind each cause, and lists how many points each test costs you. Here is an example report for a Windows PC with real-time antivirus.

Reading your score

Software around the hardware matters a lot. The reference is a desktop PC running Ubuntu in WSL2. The same PC, running natively on Windows as-is (with third-party real-time antivirus and search indexing), scored 103. That gap is one PC with those settings, not a verdict on every Windows install; the FAQ spells out the conditions.

A few things to keep in mind:

• Each cause is marked observed (a probe saw it), likely (a probe plus a matching pattern), or possible (a pattern only).
• Each fix shows roughly what it is worth if the affected tests reached reference speed. Fixes overlap, so the gains do not add up.
• Coverage says how much of the reference's test weight your machine scored. A test that could not run lowers coverage instead of being guessed.
• Single runs vary by about 10 to 15%. Use --runs 3 when you want a number to compare.

What usually slows agents down

agentperf looks for these causes. Most of them were found the hard way, on real machines that scored worse than they should have.

• Antivirus and search indexing on Windows. Real-time scanning checks every process start and every file write.
• Code under /mnt/c in WSL. On one measured PC, small-file work there was orders of magnitude slower than on the Linux filesystem.
• A slow shell profile. Codex starts a login shell for every command, so your login files (.zprofile and friends) run every time.
• Background load. One stuck system process held a measured laptop at 296-430, against about 720 modelled for that hardware when idle.
• Synced folders (iCloud, OneDrive, Dropbox), power-saving plans, and spinning disks.
• Large repos with git's fsmonitor turned off.

Commands

Add --fetch-tools when you compare machines. It downloads a pinned ripgrep build, so every machine searches with the same binary, and a pinned Node when a machine has none. Downloads are checked by SHA-256 and stored in ~/.agentperf/tools; your PATH is not touched.

agentperf remote my-mac linux-box --fetch-tools --clean
agentperf remote my-pc --wsl my-pc:Ubuntu --fetch-tools --compare fleet.html
agentperf remote my-pc --wsl Ubuntu --fetch-tools

agentperf live --dry-run                  # shows what would run and spends nothing
agentperf live --claude-model sonnet

Use it with your coding agent

Your coding agent can run agentperf for you: check each machine first, benchmark them one at a time, and explain where your agents will feel fastest. Teach it once with the bundled skill:

agentperf skill install

That copies the skill into the Claude Code, Codex, and shared agent skill folders. Nothing you have edited there is ever overwritten without --force. In Claude Code you can install the same skill as a plugin instead:

/plugin marketplace add SergeSerb2/agentperf
/plugin install agentperf

Then just ask, for example:

• "Benchmark this machine with agentperf and explain the result."
• "Compare my Mac, my Linux box, and my Windows PC (native and WSL2) with agentperf. Tell me where to run my agents."

The agent will confirm which machines you mean before it connects anywhere. The full instructions it follows are in docs/AGENTS-GUIDE.md. If you script agentperf yourself, run, report, compare, doctor, and remote all take --json=summary.json for machine-readable output, and the exit codes are stable. See docs/result-schema.md.

How it works

agentperf builds the same test project on every machine: 6,000 source-like files in 400 folders, about 49 MB. Then it times seven kinds of work.

The weights are a judgment call, guided by one developer's 6,416 real Claude Code tool calls. Most of them (79%) were shell commands, so process spawn counts the most.

The tests try to be fair across operating systems. The scored shell is bash everywhere (Git Bash on Windows), started with no profile files and with inherited shell-startup variables (BASH_ENV and friends) removed, scored copies move real bytes, the two large-file write tests make the same flush-to-device request on every OS, cold reads try to skip the file cache, and with --fetch-tools every machine searches with the same ripgrep build. Other tools (grep, git, Python, Node) are the ones each machine already has, so part of a gap can be the tools, not the hardware. Every result records the tool versions it used. docs/METHODOLOGY.md explains the rules, the statistics, and the scoring, and docs/FAQ.md answers the usual objections.

Privacy

A raw result file contains your hostname, file paths, and process names, so do not post it as is. agentperf share writes an anonymized copy and lists everything it changed. See SECURITY.md.

Contributing

Contributions are welcome. You can add a benchmark, improve a diagnosis rule, or send an anonymized result from your machine to grow the reference set. CONTRIBUTING.md explains how. To run the tests:

python3 -m unittest discover -s tests -t .

Roadmap

• More reference machines, especially Linux desktops and laptops.
• A result history on each machine, so you can compare before and after a change.

License

MIT. agentperf is not affiliated with other projects that have a similar name.