Benchmarks

In short: taskgraph doesn’t score higher than plain Claude Code, which already passes nearly every case on these builds, and it doesn’t cost less either: a later recheck found it cost about three times as much as plain on the Shell and jq builds (see Cost recheck). What it buys you is recovery: after an interruption taskgraph loop picks up from its task statuses, where a fresh plain session often stops early. Each benchmark is a PRD for a program that copies an existing tool, so the real tool serves as the oracle for hidden acceptance tests. Each test compares standard output and exit status. Before any run, the harness points the tests at the oracle itself and checks that it passes 100%. Two arms build each PRD unattended in an empty git repository, on Sonnet:

Plain: claude -p with the PRD.
Taskgraph: taskgraph init, parse-prd, then loop --trust with a budget, which is what taskgraph go runs.

Each run is capped at $15 and 110 minutes. Costs are what Claude Code reports. Times include planning but not scoring. Each row is one run, so a difference of a few cases is within noise.

Large PRDs

The PRDs are about five times the size of the SQL and Python ones below:

JS: a JavaScript interpreter, scored against node (72 cases).
Shell: a POSIX shell, scored against dash (45 cases).
jq: a jq 1.7 clone, scored against jq (42 cases).

Bench	Plain	Cost	Time	Taskgraph	Cost	Time
JS	70/72	$7.04	37 min	63/72	$8.42	51 min
Shell	45/45	$8.50	70 min	44/45	$4.83	38 min
jq	40/42	$7.52	69 min	38/42	$4.37	36 min

A second taskgraph run on jq scored 33/42 for $3.54.

Interrupted

The run is stopped partway through, then resumed the way a person would resume it:

Plain: the same prompt goes to a new session.
Taskgraph: taskgraph loop runs again.

The first phase runs under a lower budget cap, then stops. Taskgraph’s cap was 40% of what it spent uninterrupted: $3.37 for JS, $1.93 for Shell and $1.75 for jq. Plain sessions often ended early on their own, so their caps were set lower, at $1.10, $1.30 and $1.50. Both phases share the one budget and time limit.

Bench	Plain	Cost	Time	Taskgraph	Cost	Time
JS	71/72	$8.77	47 min	69/72	$5.83	39 min
Shell	39/45¹	$1.64	12 min	41/45	$2.79	26 min
jq	33/42¹	$1.72	13 min	34/42	$2.78	24 min

¹ The first plain session ended on its own, before the stop point, at $1.28 for Shell and $1.41 for jq. The second session, given the same prompt, added little.

Earlier PRDs

These benchmarks are smaller, and taskgraph should never lose on them. The results below come from the build in which one loop session works through the tasks:

Bench	Plain	Cost	Taskgraph	Cost
SQL	97/97	$1.54	96/97	$4.99
Python	79/80	$8.38	78/80	$7.23

The git-compatible VCS benchmark was not rerun on this build.

Parallel

Toolbelt is a PRD for 13 independent coreutils clones, scored against GNU coreutils 9.4 (21 cases). It compares two arms:

Plain: told to build the parts in parallel with subagents.
Taskgraph: runs loop --parallel 3. Between waves the harness merges each finished branch and marks its task done, as a person would.

Arm	Score	Cost	Time
Plain with subagents	18/21	$1.16	2.7 min
`loop --parallel 3`	0/21²	$2.36	30 min
`loop --parallel 3 --merge`	17/21	$2.30	11 min

² Its build wrote dist/src/cli.js instead of dist/cli.js, so every case failed. With that one path fixed, it scored 20/21. Without --merge, each of the 12 waves ran one task, because every tool task also edits src/cli.ts to register itself. The file guard held the other tasks back. With --merge, taskgraph merges each wave itself and resolves conflicts in shared files, so tasks run side by side.

Cost recheck

A later batch reran plain Claude Code on Shell and jq, and built the same two PRDs with taskgraph at low effort from a fixed 12-task plan. Costs are from the session transcripts.

Bench	Plain	Cost	Time	Taskgraph	Cost	Time
Shell	42/45	$2.38	18 min	43/45	$3.98	40 min
jq	38/42	$2.23	18 min	40/42	$9.61	66 min

Plain cost a quarter to a third of what it did in the runs above, and taskgraph’s jq cost was more than twice its earlier runs. Plain built each program in 19 to 27 API calls. Taskgraph used about 165, each one reading the whole session again, and on jq it wrote 2.6 times the output tokens. Taskgraph at Claude Code’s default effort, run earlier the same day, cost $7.19 on Shell and $6.37 on jq.

One task per session

The loop’s prompt then changed so each session builds one task in a few large steps, commits it, marks it done and stops, and the loop starts a fresh session for the next. That is now the default preset. Same plans, Claude Code’s default effort:

Bench	Plain	Cost	Time	Taskgraph	Cost	Time
Shell	42/45	$2.38	18 min	43/45	$3.74	25 min
jq	38/42	$2.23	18 min	36/42	$3.78	23 min

No session went past 81K tokens. Both benches together cost $7.52, against $13.56 for one session over every task and $4.61 for plain: 45% less than before, and still about 60% more than plain. Most of what is left is each fresh session reading its prompt and files again.

Interrupted at 8 minutes

The same Shell and jq builds, stopped 8 minutes in with SIGTERM (what Ctrl-C does), then resumed:

Plain: claude -p --continue in the same folder, told it was interrupted and to carry on.
Taskgraph: taskgraph loop again, one task per session.

Bench	Plain	Cost	Time	Taskgraph	Cost	Time
Shell	40/45	$3.98	36 min	43/45	$4.45	50 min
jq	40/42	$8.46	87 min	36/42	$4.15	35 min

Both benches together, against the uninterrupted runs above:

Arm	Score	Cost	vs uninterrupted	Time
Plain	80/87	$12.44	+170%	124 min
Taskgraph	79/87	$8.60	+14%	86 min

The score held for both. The cost didn’t for plain: --continue carries the whole conversation, so every later call re-reads it. On jq the resumed session reached 430K tokens and read 34M cached tokens, and it was still polishing when it was killed at 87 minutes. Taskgraph’s sessions stayed under 72K tokens: the next one started on the interrupted task from its status and its uncommitted files. One run per row, on a different day from the uninterrupted runs.

Takeaways

Uninterrupted, taskgraph ties or trails plain Claude Code on score on every benchmark. Interrupted, it scored a case or two higher on Shell and jq, which is within noise.
With no interruption, it spent about 40% less on Shell and jq in these runs, and more on JS. The cost recheck didn’t hold that up: costs swing a lot between runs, and there taskgraph cost about three times as much as plain. With one task per session it costs about 60% more than plain.
After an interruption, taskgraph resumed from its task statuses and came close to its uninterrupted score. Plain sessions often end early on their own, before the work is complete. Resumed with --continue, plain kept its score but cost almost three times as much; taskgraph cost 14% more, which made it about 30% cheaper than plain after an interruption.
On independent parts, loop --parallel --merge came within a case of plain subagents, at twice the cost and four times the time.

When to use it

What you get over plain Claude Code:

A plan on disk. Tasks, dependencies and progress notes live in .taskgraph/tasks/tasks.json, so you can read, edit and review them like code.
Clean resume. After an interruption taskgraph loop picks up from the task statuses and comes close to its uninterrupted score.
A dependency graph you can inspect. taskgraph next shows the first unblocked task, graph draws the tree and why 7 says what blocks task 7.
Unattended parallel builds. loop --parallel --merge runs independent tasks side by side and merges each wave itself.

What it costs: no better scores, more money and time with one task per session (Shell and jq together scored 79/87 for $7.52 in 48 minutes, against 80/87 for $4.61 in 37 minutes for plain), and slower parallel builds. Use TaskGraph when a build is long enough that you will stop and resume it, or when you want the plan and its progress kept in the repo. For a build that fits in one sitting, plain Claude Code is cheaper and just as good.

Welcome

Getting Started

Best Practices

Technical Capabilities