> ## Documentation Index > Fetch the complete documentation index at: https://taskgraph-ai.com/llms.txt > Use this file to discover all available pages before exploring further. # Benchmarks > How taskgraph loop compares with plain Claude Code on long builds scored by hidden tests, with and without an interruption. 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](#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](#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](#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](#interrupted-at-8-minutes). * 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. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.