Benchmarks

Numbers we actually measured.

Taken 5 and 6 November 2026 on build 0.1.17, Apple silicon, from the app a person launches rather than from a test harness. Where a figure got worse under a second look, the second look is the one printed here.

0.9 s Opens a 10,000-node canvas Launch to a window on screen. It was 4 min 24 s before the 0.1.16 fix.
78 MB Memory in use (RAM) Holding that same canvas — nine megabytes more than one of a thousand nodes.
16 MB The canvas file on disk Ten thousand nodes, their text, colours, icons and connections. 1.7 MB at a thousand.
3.6 MB The whole app, downloaded One disk image, nothing to install alongside it, no runtime to fetch.
0.26 s Adds 199 more nodes To the canvas that already holds ten thousand.
0.09 % Of the time is Thinkograf Building a 521-node diagram. The other 99.91% is the model composing it.

Opening a file

Time from launching the file to a window appearing on screen — the thing a person actually waits for. Measured on build 0.1.17, Apple silicon.

Canvas Open → window Relative
1,000 nodes 1.1 s
5,000 nodes 0.8 s
10,000 nodes 0.9 s

Before 0.1.16 the same three took 1.5 s, 81 s and 264 s. Commit 6bf9da6 clips and batches the connection strokes; all of that time had been CoreGraphics stroking edges.


Memory, and what a canvas weighs

RAM in use with the file open, against the size of the file itself. The app’s own baseline dwarfs the canvas: ten thousand nodes cost about nine megabytes more than one thousand.

Canvas · file on disk Memory (RAM) Relative
1,000 nodes · 1.7 MB file 43 MB
5,000 nodes · 7.9 MB file 84 MB
10,000 nodes · 16.0 MB file 78 MB

Panning a 10,000-node canvas with the frame-stats overlay on took it to 100 MB. The app itself is a 3.6 MB download, and the figures above include it.


What the assistant’s calls cost

The store and the agent tools, timed on canvases of each size. These are Thinkograf’s own numbers, not the round trip.

Operation At 10,000 nodes Relative
Add 199 more nodes 0.26 s
Read the whole canvas 0.47 s
Open the file (the store, not the window) 0.12 s

At 1,000 nodes the same three are 0.05 s, 0.05 s and 0.01 s.


Where the time really goes

Three diagrams built end to end by Claude Opus 5 through the shipping app, with a rig timing every call and every gap between them.

Diagram Total Relative
Small · 21 nodes · 5 calls 36.5 s
Medium · 105 nodes · 9 calls 2 min 4 s
Large · 521 nodes · 21 calls 8 min 19 s

Thinkograf spent 0.072 s, 0.139 s and 0.472 s of those — 0.20%, 0.11% and 0.09%. The rest is the model composing roughly 190 characters of JSON per node, at about 210 characters a second. Roughly a second a node, falling as the diagram grows.


What these numbers do not say

Three honest limits.

Ten thousand nodes will not fit on screen at once.

The camera stops zooming out at 10%, and framing a canvas that size needs about 1.7%. It holds ten thousand nodes; the viewport cannot show them all together.

Drawing cost per frame has not been re-measured since the fix.

On 0.1.15 a 10,000-node canvas drew at roughly 22–37 frames a second while panning. Commit 6bf9da6 changed how connections are stroked, so that figure is stale in both directions — we are not quoting a new one until it is taken again.

“About a second a node” is the model’s speed, not ours.

It was measured with Claude Opus 5. A faster or more terse model moves every one of those minutes. The part that travels is the split: Thinkograf spends a tenth of a per cent of it, and that held at every size we tried.


Method

How they were taken.

Canvases

Generated as root → 50 areas → 199 ideas each, giving files of 1.7 MB, 7.9 MB and 16.0 MB. The same three graphs were used for every run.

Opening

The file opened from Finder, window 1440×752, timed from launch to a window on screen. Not from the store opening SQLite, which is far quicker and is not what you wait for.

Agent time

Three diagrams built end to end by Claude Opus 5 through the installed app’s own MCP helper, one helper per diagram, with every call and every gap timed from a single clock. Content was composed one call at a time, never prepared in advance.

The model

A control run of five tiny calls separated the two terms: about 3.4 s fixed per call, then roughly 210 characters a second of composing. That predicts every run within 4%.

A node costs an assistant 170–210 characters of JSON to write, and that is what sets the clock. Richer nodes — category, colour, icon, detail — cost more than plain ones.

Measure it yourself.

The app ships with a frame-stats overlay on ⌥⌘F. Nothing here is behind a licence check.