Cortex vs. frontier AI models on real construction drawings
One test: 118 real plan sheets, read by Cortex and six models from OpenAI, Google and Anthropic.
- 97%
- of what Cortex flags is right
- Best frontier model, GPT 6.1 Terra: 79%
- 96%
- of the objects on a sheet, found
- Best frontier model, Claude Fable 5.2: 73%
- <$0.01
- to read one sheet on Cortex
- Frontier models: $3.25 to $33.67 for the same sheet
The whole test
More accurate, and far cheaper
Each point is one system: how accurate it was, against what it cost to read one sheet. Cortex sits alone in the top-left corner. The six frontier models cluster lower and well to the right.
Accuracy against cost to read one sheet
Up is more accurate. Left is cheaper. Cost is on a log scale: each step is ten times the last.
- SystemScoreCost
- Cortex0.97<$0.01
- 1GPT 6.1 Terra0.72$3.25
- 2Gemini 4 Argon0.72$3.78
- 3Gemini 4 Carbon0.75$4.63
- 4GPT 6.1 Sol0.68$9.41
- 5GPT 6.2 Astra0.69$24.00
- 6Claude Fable 5.20.72$33.67
Accuracy
How much each system got right
The combined accuracy score balances two things: how much of what a system flags is right, and how much of what is on the sheet it finds. Cortex scored 0.97. The best frontier model, Gemini 4 Carbon, scored 0.75.
Accuracy finding objects on a drawing
Combined accuracy score, 0 to 1. Higher is better.
- Cortex0.97
- Gemini 4 Carbon0.75
- Gemini 4 Argon0.72
- GPT 6.1 Terra0.72
- Claude Fable 5.20.72
- GPT 6.2 Astra0.69
- GPT 6.1 Sol0.68
Why the gap exists
Drawings are read in small symbols
Much of what a drawing says is in marks a few pixels wide. The frontier models found most of the large object tags, few of the small ones, and none of the 461 smallest. Cortex found 95% of object tags across every size.
Share of object tags found, by size on the sheet
Tag size is its shorter side on a sheet rendered 4,800 pixels wide. The darker bar is the lowest frontier model and the lighter bar the highest.
- Large tagsover 20 pixels86 to 90%
- Small tags11 to 20 pixels9 to 29%
- Smallest tagsunder 10 pixels0 of 461
Cost to read one sheet
Hundreds of times cheaper to run
A frontier model reads a sheet in pieces: about 35 enlarged tiles, then a second look at every object it flags, repeated for each object type. Cortex reads the sheet once. All eleven object types cost <$0.01 a sheet on Cortex, $3.25 on the cheapest frontier model and $33.67 on the most expensive. Model costs are measured usage at list prices, November 2026.
Cost to read one sheet for all eleven object types
Bars are drawn to scale, so Cortex is the dot at the start of the axis.
- Cortex<$0.011×
- GPT 6.1 Terra$3.25450×+
- Gemini 4 Argon$3.78520×+
- Gemini 4 Carbon$4.63640×+
- GPT 6.1 Sol$9.411,300×+
- GPT 6.2 Astra$24.003,330×+
- Claude Fable 5.2$33.674,670×+
Maximum shown is $33.67 per sheet.
On a sheet
The eleven object types we tested
Pick an object type to see where it appears on a plan, and how Cortex scored on it against the best of the six frontier models.
Object type 01 / 11
Doors
9 on this sheet, each one bracketed.
- Cortex0.98
- Best frontier model0.85
+0.13 Cortex lead on doors.
Combined accuracy score, 0 to 1, from the in-house benchmark, November 2026. The sheet is an illustration.
The sheet is an illustration, not one of the 118 test sheets.
The numbers
Every result, in two tables
Trunk Tools in-house benchmark, November 2026: eleven object types on 118 real plan sheets.
Reading drawings: accuracy and cost, by system
| System | Combined accuracy score | Cost per sheet | vs Cortex |
|---|---|---|---|
| Cortex | 0.97 | <$0.01 | 1× |
| Gemini 4 Carbon | 0.75 | $4.63 | 640×+ |
| Gemini 4 Argon | 0.72 | $3.78 | 520×+ |
| GPT 6.1 Terra | 0.72 | $3.25 | 450×+ |
| Claude Fable 5.2 | 0.72 | $33.67 | 4,670×+ |
| GPT 6.2 Astra | 0.69 | $24.00 | 3,330×+ |
| GPT 6.1 Sol | 0.68 | $9.41 | 1,300×+ |
Combined accuracy score, by object type
| Object type | Cortex | Best frontier model | Cortex lead |
|---|---|---|---|
| Windows | 0.97 | 0.66 | +0.31 |
| Sprinklers | 0.94 | 0.67 | +0.27 |
| Lighting fixtures | 0.93 | 0.70 | +0.23 |
| Switches | 0.98 | 0.76 | +0.22 |
| Object tags | 0.97 | 0.75 | +0.22 |
| Receptacles | 0.95 | 0.74 | +0.21 |
| Columns | 0.95 | 0.78 | +0.17 |
| Air terminals | 0.94 | 0.77 | +0.17 |
| Doors | 0.98 | 0.85 | +0.13 |
| Toilets | 0.99 | 0.94 | +0.05 |
| Grid line markers | 1.00 | 0.99 | +0.01 |
Beyond one sheet
A project is thousands of documents, not one
Take a project with 10,000 documents averaging 5 pages each. At about 500 tokens a page, that is roughly 25 million tokens of text, more than a general model takes in one conversation. So someone has to choose which documents to hand it, for every question.
Give a general model the right three documents and it will answer well. Your project has 10,000, and knowing which three is the job.
Cortex reads the whole project once, drawings included, and keeps what it read. Every question after that searches all of it.
This section is an illustration worked from round numbers, not a test result. Everything above it was measured.
Method
How the test was run
- 01
Same sheets for everyone
118 real plan sheets with 25,483 hand-labelled objects across 11 object types. None were used to tune any system.
- 02
Frontier models given a fair run
Each sheet was cut into overlapping tiles and enlarged so small symbols were legible. Every candidate was then shown back to the same model to confirm or reject, which roughly doubled their scores. Prompts were tuned on one model and reused unchanged for the rest.
- 03
A strict definition of a hit
A detection counted only if its box overlapped the true object by at least half. Precision is how often a flagged object was right; recall is how many real objects were found.
- 04
Costs at list price
Model costs use measured usage at published list prices in November 2026. Cortex's cost is the measured computing cost of reading one sheet, with the system running at full load.
This is our own test, not an independent one. It covers eleven object types that Cortex reads in production at a score of 0.93 or better, and it measures one task: finding objects on a plan sheet. We run it again as new models are released and update this page when the results change.
These are excellent general-purpose models, and they keep improving. In this test they came within 0.01 of Cortex on grid line markers and scored 0.94 on toilets and 0.85 on doors. A model tuned by its own maker for this task might score higher than it did here.
FAQ
Questions about the benchmark
Partly. In Trunk Tools' in-house benchmark (November 2026, 118 real plan sheets), six frontier models from OpenAI, Google and Anthropic scored 0.68 to 0.75 on combined accuracy at finding objects on a sheet. The best was 79% precise and the best found 73% of the objects. They did well on large, distinct symbols such as grid line markers and missed many small ones. Cortex scored 0.97 on the same sheets.
Cortex, the Trunk Tools AI layer, was 97% precise and found 96% of the objects on 118 real plan sheets, across 11 object types and 25,483 hand-labelled objects. This is an in-house test run in November 2026.
Much of what a drawing says is in symbols a few pixels wide. In this test the frontier models found 86 to 90% of large object tags, 9 to 29% of small ones, and none of the 461 smallest. Cortex found 95% of object tags across every size.
Reading all 11 object types on one sheet cost <$0.01 on Cortex. The same sheet cost $3.25 on the cheapest frontier model tested and $33.67 on the most expensive, at published list prices in November 2026. A frontier model reads a sheet as about 35 enlarged tiles and then checks each object it flags. Cortex reads the sheet once.
Six current frontier models: Gemini 4 Carbon, Gemini 4 Argon, GPT 6.1 Terra, Claude Fable 5.2, GPT 6.2 Astra, GPT 6.1 Sol. Each one read the same 118 sheets through the same method, with prompts tuned on one model and reused unchanged for the rest.
One task: finding objects on a plan sheet. It covered 11 object types: doors, windows, grid line markers, toilets, switches, object tags, columns, receptacles, air terminals, sprinklers, lighting fixtures. A detection counted only if its box overlapped the true object by at least half. The results say nothing about how these models perform on other tasks.
No. It is Trunk Tools' own test, run in November 2026. None of the 118 sheets were used to tune any system, and the method is published on this page. A model tuned by its own maker for this task might score higher than it did here. We run the test again as new models are released and update the page when the results change.
Let builders build
See Cortex read your drawings
Bring a drawing set to the demo and we'll run it live.