GPT-6 Astra's impact on CAD

Oleg Żero — Fri, 11 Sep 2026 11:07:07 +0000

Introduction

I get uneasy when every new model release arrives with an AGI announcement attached. In engineering the bar sits somewhere else: things either work or they don't, and when they don't, it gets expensive, and occasionally it gets dangerous. So one distinction is worth holding on to. "It looks like it did the job" is not the same as "it did the job".

AI is evolving quickly and will probably keep evolving. But a model release adds options. It does not, on its own, decide whether a class of engineers gets replaced. My guess runs the other way: they will be needed more.

This article asks a narrow question: what does Astra actually change in CAD-related work? The situation is fresh, since the model was released very recently, and I treat the evidence accordingly. I look at three areas that match my own interests: architecture, product design, electronics and hardware. Everything outside them is out of scope here. For each area I collected references to projects where people tried the model in practice and set them next to the official releases, then added my own reading of where we stand given current experience and understanding. If only one of those domains interests you, jump straight to it.

A warning about the evidence base

Almost every "test" published so far is either an OpenAI demo or a quick proof of concept from a passionate engineer or blogger. As of writing this article (10th September 2026), we still need to wait for proper production deployments to see.

What Astra is and what it is not

GPT-6 Astra is OpenAI's general multimodal model, released on 2026-09-03 under the model ID gpt-6-astra. It is proprietary: there are no open weights, and the only way in is the API (API documentation). The context window is about 1 050 000 tokens, max output 128 000, and the knowledge cutoff is 2026-04-30 (scalevise). It is available through the OpenAI API, ChatGPT Pro/Business/Enterprise, Microsoft Azure Foundry and AWS Bedrock (Azure). One parameter matters more than the rest for anything agentic: reasoning.effort, which runs from low to max. Going from low to max costs roughly 10× more and takes roughly 8× longer (Artificial Analysis).

One naming note, because it otherwise wastes time. This is not Google Project Astra, which is a completely different product: a multimodal assistant in Gemini Live. The shared name clutters every search (Android Central).

Astra is not a CAD model

It is a general model that writes code and operates a computer. Everything it does in CAD, it does through code (Python, CadQuery, bpy) or by clicking in a GUI. That has consequences for everything below.

Multimodality does not change the mechanism underneath. Astra's understanding of a problem, of space, of an engineering task rests on the classic LLM machinery: a context window, tools, and a large number of parameters. Its ability to work with CAD tools comes down to two things: understanding what is displayed on the screen, and formulating the code that goes through the API.

Benchmarks

What they say

Fig. 1 — BenchCAD Vision2Code, September 2026. Every one of these numbers was submitted by the vendor that scored it. Data: benchcad.com/leaderboard. Chart: author's own.

The loudest voice regarding CAD is BenchCAD: a benchmark from May 2026, authored at the University of Virginia (Zhang, Liu, Chen, Li, Yang, Peng, Chen). It holds 17 900 execution-verified CadQuery programs across 106 families of industrial parts, with parameters tied to 47 standards (ISO/DIN/EN/ASME/IEC) (arXiv 2605.10865, GitHub).

What it measures: the main metric is Voxel IoU at 256³ resolution, plus Chamfer Distance, Hausdorff Distance and Feature-F1. The tasks are Vision2Code, CodeEdit, Vision-QA and Code-QA. Scoring is execution-grounded, computed by a CAD kernel rather than an LLM judge. That is a good construction (arXiv).

It also deserves credit for going past visual similarity. This benchmark tests parametric operations such as sweep, loft, twist, not to mention sketch+extrude. And here is how Astra compares to other models: Astra 95.9%, Claude Fable 5.1 84.3%, GPT-5.6 Sol 83.3%. If you'd like to know more, here is the link to the BenchCAD leaderboard.

What they don't say

Fig. 2 — The same model on the same benchmark, 37.2 points apart, because of two API settings. Data: ARC Prize and OpenAI. Chart: author's own.

The result is, so far, self-reported and not independently verified. The BenchCAD leaderboard explicitly distinguishes results "re-graded from submitted predictions" from "vendor self-reported voxel IoU, not re-graded". Both OpenAI's 95.9% and Anthropic's 84.3% fall into the second category (leaderboard, confirmed by direct check).

Furthermore, the result applies to the model operating as an agent, one that can render, measure and make corrections before answering. So far, nobody has published a study of how it performs there (The New Stack, Vellum).

A high IoU metric does not guarantee that a designed part is error free. The BenchCAD team themselves report an example of a part whose geometric similarity reached 96.1% despite being faulty: a follow-up operation closed an opening which was supposed to be left open (IBTimes).

Finally, what is compared is not always "apples to apples". To give you the context, here are some other benchmarks.

Benchmark	Astra	Predecessor / rival	Source
BenchCAD Vision2Code	95.9%	Sol 83.3% · Fable 5.1 84.3%	leaderboard
OSWorld 2.0 (computer use)	72.6%	Sol 65.7%	officechai
GPQA Diamond	96.0%	Sol 94.6% · Gemini 3.8 95.3%	vellum
FrontierMath Tier 4 v2	97.6%	Fable 5.1 87.8%	officechai
Humanity's Last Exam	57.2%	Fable 5.1 65.0%, Astra loses	emergent.sh
ARC-AGI-3	62.7% (ARC harness) vs 99.9% (OpenAI harness)	n/a	ARC Prize

How to read the numbers?

ARC-AGI-3 is the textbook example of how to read numbers like these. The same Astra, the same attempt: 62.7% on the standard ARC Prize harness and 99.9% on OpenAI's own harness. The 37-point difference comes from two API settings ("retained reasoning" and "compaction") that OpenAI did not disclose in the main announcement (ARC Prize, OpenAI, The New Stack).

Independent measurement is less enthusiastic. On the Artificial Analysis Intelligence Index: Astra 61.2, GPT-5.6 Sol 60.9, Claude Fable 5.1 65.7, higher than Astra. Astra is 2.5× more expensive than Sol, and the total cost per task is about 75% higher (Artificial Analysis).

OpenAI's system card has no section on CAD, 3D or geometry. It focuses on safety. There is also no public model card with architecture and training data (deploymentsafety.openai.com).

Key takeaway

The jump on BenchCAD is real and large (+12.6 pp over the predecessor), but it is a jump in generating CAD code from views in a loop with tools, confirmed by the vendor alone. That is something other than "the model understands design".

So let's dive in to see how well it does in specific engineering areas.

Architecture and BIM

Capabilities demonstrated so far

OpenAI's official demo, verified directly, runs from an architectural brief to an editable Blender scene to a walkthrough in Unreal Engine 5. Astra writes scripts through the Blender Python API (bpy) and also opens and inspects the scene through computer use (OpenAI Developers).

What OpenAI admits in that same demo is worth reading closely; the quotes below are verified. The geometry consists of "modeled mesh objects": meshes, not a parametric model. Pillows and bedding are "authored shapes", chosen so that nobody has to run a cloth simulation. "Some shader behavior was approximated", so the look needed manual inspection. Mirrors in Unreal show reflection artifacts. And the closing caveat is OpenAI's own: "the concept plan still needs professional review of the site, structure, and building requirements before it could inform construction". What OpenAI did not publish is execution time or token cost. I checked directly; those numbers are not there.

Outside the vendor demo the picture is mixed. A reconstruction of the Palace of Fine Arts in Blender holds architectural detail against the reference photos (X/tomkrcha, via awesome-gpt-6-astra). A pavilion test (courtyard, plinth, three walls, colonnade, roof) produced 6 columns on one run and 11 on another, so the model does not consistently hold a specified number of elements (blendermcp.org). And three hours of work on a house model with interior layout ended with wardrobes turning into windows and a manual correction (Lenny's Newsletter).

What is not quite there yet

As I mentioned earlier, the "understanding" of CAD is largely based on reasoning over existing CAD tools' APIs and utilising MCP servers and plugins, whenever they exist. For Revit, Autodesk has officially stated that the Revit 2027 MCP server is to be integrated with Autodesk Assistant and supports an arbitrary MCP-compatible LLM.

Until then there is the community layer: RevitCortex (github.com/LuDattilo/RevitCortex) with 173 tools, Revit 2023–2027, supporting Claude/Codex/Gemini and any MCP client; revit-mcp-server from the same author, with 80+ tools; and revit_mcp (PiggyAndrew) plus RevitMCP (oakplank, pyRevit).

Although none of these projects explicitly mentions GPT-6 Astra, they act via the MCP standard, so there is no reason to assume that Astra would, for some reason, be excluded. This means more powerful assistance, fewer mistakes, an accelerated workflow, but not necessarily less time spent.

Why?

First of all, BenchCAD tests the code. It does not, however, deal with regulatory issues, quality control, clash detection or code-checking. To realise a complete BIM project, dozens of steps beside drawing exist, executed by entire teams and departments. Given just a few days, it is natural that no complete and fully Astra-based project has been executed and documented. Despite a more powerful model, these steps are not eliminated, and any mistake that can inevitably happen has to be found and corrected. Parametric-architecture describes an "architect's workflow with Astra", but it is a speculative scenario ("at 9:00 the designer opens…"), so it is safer to treat that kind of AI-based work as marketing content rather than engineering truth.

What existed before Astra and continues to exist

Just for the reference, let me present a few tools that have already been developed and offer commercial help in the CAD process for architecture. These dedicated tools are more mature and BIM-native.

Autodesk Forma covers the early phase: massing options, wind/sun/noise analysis, embodied carbon (Autodesk). Finch3D generates floor plans from massing and integrates natively with Rhino/Grasshopper/Revit at €49–1000/month, without structural or MEP coordination and without construction documentation (illustrarch). WiseBIM turns PDF/CAD/image input into a native Revit model for \$29/month (myarchitectai). Glyph is a Revit plugin driving sheets, tagging and dimensioning with natural-language commands, at $600/year.

Clash detection has mature non-AI solutions: ifcclash (IfcOpenShell, AGPL-3.0) and Clash-Detection-Matrix-Automation. ArchiCAD 29 beta ships a built-in AI Assistant, but it cannot do numerical analysis (average heights, counting); it only filters and describes elements, with MCP announced for after release (Architosh).

The manual baseline is worth keeping in view: LOD 200 (plans, roof, walls, windows) takes 5–10 working days, LOD 300 two to three weeks, LOD 350 with structure and MEP three to five weeks (CAD Crowd).

Entry level shifting

Again, so little time has passed since the release of the model that it is hard to find professional documented cases that would tell the real price of tokens consumed. For reference, a rough calculation: at 10 million input tokens per day with a 70% cache hit rate, the bill lands around \$4110/month (Sol: \$1644) (Yotta Labs).

Three integration paths, ordered from the easiest:

Python + bpy / IfcOpenShell. The fastest one: the model writes the script, you run it. It requires nothing beyond an API key. My read: this is the realistic entry threshold today.
Responses API + MCP. For Rhino/Grasshopper a proof of concept exists (Rhino/GH MCP v0.1.6); for Revit it does not.
Computer use (driving the Revit GUI). Works without an API, but slow and brittle.

There is also a regulatory blocker that is easy to miss: Astra has no compliance certification (HIPAA, SOC 2), no built-in audit logging, no legal hold and no data retention controls. For a design office working on client documentation, that is a problem in itself (layer3labs).

Product Design and Mechanical CAD

Capabilities demonstrated so far

The AI gateway to CAD is the code. So far this is CadQuery, build123d, OpenSCAD, KCL: the model writes Python, the CAD kernel executes. This is where the whole BenchCAD result lies. The key difference is the feedback loop that lets the model verify its own results. build123d-mcp raises the CADGenBench score from 0.360 to 0.457, and the share of correct models from 88% to 100%, purely because the model sees a render of what it built and corrects it (build123d-mcp).

My take on this

This is the single most important technical observation in the whole research. The value does not sit in the model itself as much as it is related to the model - kernel - render loop.

A few things stand around it. OpenSCAD comes out better than build123d for LLMs at plain generation: about 3 errors versus 40 (33 with help), so 3–4× fewer repair loops, because the syntax is simpler (grandpacad). Onshape has an official MCP server for FeatureScript since 2026-08-13, with Claude/ChatGPT/Gemini generating FeatureScript code (PTC). FreeCAD MCP exists in several independent open source implementations, free of charge; it handles primitives, booleans and patterns, and does noticeably worse with constrained sketches and fillet chains (freecad-mcp, mcp.directory).

What is not quite there yet

Fig. 3 — Every closed-source model handles the single block. None handles the hinge assembly: missing mounting holes, misaligned leaves, a missing pin, parts that interfere or come apart. Figure from ASSEMCAD, CC BY 4.0 — the lower band is the authors' own method, so read the upper band for the evidence.

This is the heart of the question "does it understand design". The answer is: not in the places where it hurts. The evidence, all peer-reviewed:

Assembly constraints. The LLM generates code bolting screws into gear meshes and creates "phantom features" in places where an operation failed. When satisfying constraints it hallucinates edges that do not exist, which cascades into logical errors, even with a complete set of input data. The authors state it outright: this is a limitation of the transformer architecture, not a gap in knowledge (ASSEMCAD, arXiv 2607.05123).
Coordinate systems and face selection. A milled feature in the wrong reference frame, a stale local face selection, holes shifted, components piled up at the origin: invisible at the level of the code, fatal in the CAD kernel (arXiv 2508.00843).
Tolerances and GD&T. The model can read a standard, but not infer its consequences. A full GD&T evaluation for LLMs does not exist as a public benchmark, which makes it a gap, not a result.
Design intent. The 96.1% IoU case with the closed opening, quoted above, is exactly this class of error.
DFM/DFA. Draft angles, wall thicknesses, pocket depths, undercuts, assembly order: parts look good and cannot be made.

To give you more context: a benchmark from April 2026 recorded 10 professional design engineers (8–13 years of experience) at work and captured their natural change requests, giving 192 requests, 384 edits and 28.4 hours of work (arXiv 2604.16170). The best model (GPT-5.2) landed 53 percentage points below the experts in a human acceptance test (verified). One caution against over-reading it: the paper is from April, Astra is not in it and cannot be. Verified directly. It shows how deep the gap was just before Astra, not how deep it is now — and the version of this figure that circulates with Astra's name attached to it is one of the claims I throw out further down.

My read: the absence of an Astra result on neuralCAD-Edit is itself information. OpenAI shows BenchCAD, which is generation from scratch out of views. Editing an existing model according to an engineer's intent, it does not show. And the second one is closer to a design engineer's real work.

What existed before Astra and continues to exist

Again, a few reference examples that show the capability level prior to Astra.

cadrille (ICLR 2026): DeepCAD IoU 92.2, Fusion360 84.6, share of invalid outputs below 0.2%, from a 2B-parameter model on Qwen2-VL (arXiv 2505.22914).
CAD-Recode: a fine-tune of Qwen2-1.5B on 1 million scripts, 10× better than its predecessors (arXiv 2412.14042).
Backflip AI (August 2026): scan/mesh to editable CAD with a feature tree. Digitizing a part drops from about \$1500 to about \$10, and the time to 1–5 minutes, as an add-in for Fusion 360, with automotive deployments. It is optimized for turned and 3-axis milled parts, not universal (3D Printing Industry, BusinessWire).
SolidWorks 2026: BREP to parametric conversion (beta), PDF drawing to 3D part (beta), 255+ commands in natural language (SolidWorks).
The research direction that works is grounding in a solver: Embodied CAD (arXiv 2606.31252), AIDL (arXiv 2502.09819), ASSEMCAD. All of them say the same thing: an LLM plus a verifying solver, not an LLM alone.
The manual baseline: a simple part takes 3–5 working days; a sand casting study (part, pattern, cavity, simulation) 20–40 hours. Freelance rates in the US run $75–130/h (CAD Crowd).

Hardware and PCB Design

Fig. 4 — One PCB project. The drafting time collapses; the verification burden does not. Data: Station X. Chart: author's own.

This area has by far the best documented criticism from all three areas. To discuss it, let's discriminate three levels, as they differ rather significantly.

Level	State	Evidence
Schematic + component selection	Works best	prompt → editable schematic with real parts in minutes, protoflow
Placement + routing	Weak, geometry hurts	see below
DRC / manufacturing / Gerber	Stays with deterministic tools	"deterministic rule checkers must make the final call", protoflow

Let's start with a few failures

All four come from one project, documented by Nathan House in AI PCB Design: My AI Tried to Make Itself Physical. His numbers, his words in quotation marks.

The AI placed a via 0.0285 mm from an LED solder pad — "a copper via I had placed 0.0285 millimetres from an LED pad".
The AI board: 168 design rule violations. The human board: 0. "The AI's had 168 design-rule violations. The human's board had zero".
Courtyard zone collisions: two components placed "a comfortable-looking distance apart" that violated their keep-out boundaries twice.
The same project: a 428-hour layout came down to about 38.5 hours of human input, roughly 11× less human time — but with those 168 violations left to fix.

Observation

This is the honest picture. A dramatic speed-up of the first approximation, plus a shift of the work onto verification. Not "AI designed the board".

What has been proven

OpenAI claims that Astra carries out placement and routing in KiCad, from schematic to a finished board (OpenAI), with a thread about it on the KiCad forum.
Astra has NO EEBench result. The circulating figure of 69.3% is false. The EEBench blog says plainly "We do not have a GPT-6 Astra result yet". The leader is Claude Opus 5 at 61.6% (as of 2026-09-01) (EEBench, verified).
A conflict of interest around EEBench: the benchmark was built by the atopile team, the authors of a language for describing circuits as code. Worth remembering while reading their results.
The most interesting real signal is a Hackaday comment (author: Em): three PCBs "vibe coded", all three worked on the first send to production, but "The routing can look a little wonky (which started me down the rabbit hole of making a rust fork of freerouting), but its really wild how well it works." (Hackaday, verified).
The second real signal: the Protoflow case study. The AI made small mistakes (missed through-holes, an undersized central pad), the API cost was $50, and the boards worked after fabrication (Protoflow).

Entry level shift

PCB design has the best open source landscape comparing to the other two areas. That's perhaps why things will be verified much faster. Thanks to the community of all nerds world wide.

Let's bring on some summary of currently existing tools.

KiCad + MCP: several independent servers built on the official IPC API, kicad-mcp on PyPI, Seeed-Studio, mixelpixx. Adafruit wrote about it (Adafruit blog).
atopile describes a board in declarative .ato code, with native KiCad integration, open source. For an LLM this is the same advantage CadQuery brings in mechanical work: text instead of clicking (atopile).
Flux.ai is an AI-native EDA in the browser, with a library of 750 000 components carrying datasheets (grounding that limits hallucination) and a public MCP server (Flux).
Non-LLM autorouting is more mature than the LLM kind: Quilter (physics, "millions of synthetic boards") and DeepPCB (reinforcement learning, InstaDeep) (Quilter vs DeepPCB vs Flux).
For context: EAGLE ends support on 2026-06-07, with migration to Fusion Electronics (Autodesk forum).

Takeaways

Money facts

Fig. 5 — What the edits actually look like — "convert to window frame", "make the cutout shallower by 10mm but keep the spanner the same" — plotted against what they cost. Note the x-axis tops out around $30 per edit. Figure from neuralCAD-Edit, CC BY 4.0.

Let's wrap up the cost. After all, Astra isn't cheap, but so aren't engineers.

API pricing: \$10 per million input tokens, \$50 per million output, cached input \$1 per million, cache writes \$12.50 per million. Above 272 000 input tokens: \$20/\$75 (Yotta Labs).
2.5× more expensive than GPT-5.6 Sol, with cost per task about 75% higher (Artificial Analysis).
A real reference point for agentic work: completing the game Portal autonomously took 3336 tool calls and $571.18 in API cost (Tom's Hardware).
Work in 3D generates millions of output tokens through self-correction loops (Neural4D).
The reference point for PCB: $50 of API for a board that worked.
NOT FOUND: the token cost for a real architectural project, for a typical mechanical assembly (say a 5-part mechanism), or for complete documentation.

The cost pattern is predictable

A single part or board runs to tens of dollars; agentic work with a long self-correction loop runs to hundreds. At a design engineer's rate of $75–130/h the break-even point is low, but it only counts after subtracting the time spent on verification.

Hype...?

Checked directly, worth listing separately, because these circulate around the web:

"Astra scores 69.3% on EEBench (PCB)": FALSE. EEBench states plainly that there is no Astra result. EEBench
"Astra lands 53 pp below experts on neuralCAD-Edit": garbled. That number refers to GPT-5.2, in an April 2026 paper that does not include Astra. To be clear about what I am rejecting here: the measurement is sound and I lean on it earlier in this article, where it shows how wide the gap was immediately before Astra. What is wrong is the attribution, not the number. arXiv 2604.16170
"BenchCAD 95.9% is verified": no. Self-reported by OpenAI, not re-graded by the BenchCAD team. leaderboard
"Astra models CAD in Blender": a conflation of terms. In Blender, Astra generates meshes through bpy. BenchCAD is a separate test of generating CadQuery code. Two different things glued into one narrative. Kingy, Neural4D
"91 projects made with Astra": the catalogue exists, but its entries carry notes like "ongoing; no completed board", "may not be usable", "render pending". gist phuaky

No evidence...

I found no evidence of a step change in the understanding of assembly, fits and tolerances. The change is somewhere else: in the reach of tool control and in the quality of the first approximation.

The impact of Astra on CAD work

Can a noob in CAD do the CAD work?

Partially. Whenever a task is simple and well defined, models such as Astra significantly lower the entry level of getting (some)thing done. Be it a prototype, a simple part, a PCB with known components or a conceptual visualization, prompting and patience is often more than enough to get to the first sketch. The difficulty, however, is the lack of ability of a freshman to spot errors that simply appear as job well done. This observation isn't limited to CAD, but it is often more challenging to test.

With Astra, a layman gets access to the first approximation of the result, but not to the final result. The biggest impact, therefore, appears where mistakes costs are low. That means DIY work, home 3D printing, single proof of concept, etc. As you may notice, not much has actually changed.

Should CAD professional know AI?

Not really. The days of needing to know machine-learning principles and frameworks to get anything started are gone. With API keys and python scripts, MCP servers (e.g. KiCAD, FreeCAD, Onshape, Blender) or plugins, the cost of adding AI to workflows is largely determined by LLM providers and tokens.

The key skills, however, are not "prompt engineering", but the ability to build verification and an iterative approach. The evidence: +27% on the score and 88%→100% correctness from adding nothing but a render to the loop (build123d-mcp). The fundamental strength of a CAD professional is the ability to describe what a correct solution means in a way that is doable by machines. For these people, getting access to better models is like giving faster cars to people that already know how to drive.

The effort now shifts

True CAD professionals are quick to draft first versions and modifying existing drawings. Tools that they use have also been evolving "UX-wise". Therefore, despite shortening the time to create first versions of drawings and writing scripts, this aren't the biggest wins. However, finding documentation, converting scan to mesh and mesh to CAD is where significant portion of time gets saved.

On the flip side, the biggest dangers and hence time thieves are the verification and testing, especially against quiet mistakes. Defining acceptance criteria and responsible design matter much more now, putting more emphasis on deriving a thorough design conceptual plan and review.

What follows is my personal view rather than anything I can hand you a citation for. These are the conclusions I draw:

The direction is already visible: LLM plus solver, not LLM alone. Embodied CAD, AIDL, ASSEMCAD, build123d-mcp: four independent pieces of work say the same thing. The next real jump will come from better coupling with the kernel, not from a bigger model.
Dedicated models will not disappear. cadrille (2B parameters) holds DeepCAD IoU 92.2 at a fraction of Astra's cost. Narrow tasks will keep escaping to small models.
The bottleneck stops being geometry and becomes unstructured data: BOMs, DFM rules, standards, the history of design decisions. That is already visible in the Fusion and Onshape tooling.
What I would not expect within a year: autonomous design of safety-critical parts. The blocker is architectural (ASSEMCAD) and regulatory (no certification, no auditability), not "not enough data".

References

Source	Type	Credibility	Note
dokumentacja API	vendor blog / doc	`OFFICIAL`	—
scalevise	trade press / blog	`PRESS`	—
Azure	vendor blog	`OFFICIAL`	—
Artificial Analysis	independent measurement	`PAPER`	—
Android Central	trade press	`PRESS`	clarifies this is not Google Project Astra
arXiv 2605.10865	paper	`PAPER`	authors from UVA, no OpenAI funding trace
BenchCAD GitHub	repo	`OFFICIAL`	—
arXiv (HTML)	paper	`PAPER`	—
BenchCAD leaderboard	leaderboard	`OFFICIAL`	clearly separates self-reported from re-graded results
The New Stack	trade press	`PRESS`	—
Vellum	trade press	`PRESS`	—
IBTimes	news report	`PRESS`	quotes verified verbatim
officechai	trade press	`PRESS`	—
emergent.sh	trade press	`PRESS`	—
ARC Prize	benchmark blog	`OFFICIAL`	shows harness impact on the score
OpenAI (ARC-AGI-3 settings)	vendor blog	`OFFICIAL`	—
The New Stack (ARC-AGI)	trade press	`PRESS`	—
Artificial Analysis (benchmarking Astra)	independent measurement	`PAPER`	only independent price/performance measurement
System card	vendor document	`OFFICIAL`	no CAD/3D section
OpenAI Developers (architecture demo)	vendor blog	`OFFICIAL`	honestly lists limitations; interested party
X/tomkrcha, via awesome-gpt-6-astra	community repo	`FORUM`	—
blendermcp.org	trade press	`PRESS`	—
Lenny's Newsletter	newsletter / anecdote	`FORUM`	—
parametric-architecture	industry blog	`PRESS`	speculative scenario, not a documented pilot
Autodesk (Forma)	vendor blog	`OFFICIAL`	—
illustrarch (Finch3D)	trade press	`PRESS`	—
myarchitectai	trade press	`PRESS`	—
ifcclash	repo	`CODE`	—
Clash-Detection-Matrix-Automation	repo	`CODE`	—
Architosh	trade press	`PRESS`	—
CAD Crowd (LOD timelines)	trade press	`PRESS`	—
Yotta Labs	trade press	`PRESS`	—
Rhino/GH MCP v0.1.6	repo / MCP listing	`CODE`	proof-of-concept only
layer3labs	trade press	`PRESS`	notes lack of compliance certification
build123d-mcp	repo	`CODE`	hard numbers on feedback-loop value
grandpacad	trade press	`PRESS`	—
PTC (Onshape MCP)	vendor press	`OFFICIAL`	—
freecad-mcp	repo	`CODE`	—
mcp.directory	trade press	`PRESS`	—
ASSEMCAD, arXiv 2607.05123	paper	`PAPER`	strongest evidence of an architectural limitation
arXiv 2508.00843	paper	`PAPER`	—
neuralCAD-Edit, arXiv 2604.16170	paper	`PAPER`	10 professional engineers, real edit requests; no Astra result
cadrille, arXiv 2505.22914	paper	`PAPER`	—
CAD-Recode, arXiv 2412.14042	paper	`PAPER`	—
3D Printing Industry (Backflip AI)	trade press	`PRESS`	vendor numbers, independent coverage
BusinessWire (Backflip AI)	press release	`OFFICIAL`	—
SolidWorks	vendor page	`OFFICIAL`	—
Embodied CAD, arXiv 2606.31252	paper	`PAPER`	—
AIDL, arXiv 2502.09819	paper	`PAPER`	—
CAD Crowd (freelance rates)	trade press	`PRESS`	—
protoflow (PCB design guide)	trade press	`PRESS`	—
Nathan House, AI PCB Design: My AI Tried to Make Itself Physical	case study	`PRESS`	168 DRC violations vs 0, concrete numbers; quotes verified against the source
OpenAI (Astra launch)	vendor blog	`OFFICIAL`	—
forum KiCad	forum thread	`FORUM`	—
EEBench	benchmark	`PRESS`	built by atopile team, conflict of interest
Hackaday + comments	outlet + forum	`FORUM`	best real-world signal from practice
Protoflow (case study)	trade press	`PRESS`	$50 API cost, boards worked after fab
kicad-mcp on PyPI	repo	`OFFICIAL`	—
Seeed-Studio	repo	`CODE`	—
mixelpixx	repo	`CODE`	—
Adafruit blog	trade press	`OFFICIAL`	—
atopile	repo	`OFFICIAL`	—
Flux	vendor blog	`OFFICIAL`	—
Quilter vs DeepPCB vs Flux	vendor comparison	`OFFICIAL`	—
Autodesk forum (EAGLE EOL)	vendor forum	`OFFICIAL`	—
Tom's Hardware (Portal run)	trade press	`PRESS`	—
Neural4D	industry blog	`PRESS`	sober mesh/CAD distinction
The Hacker News (ExploitBench)	trade press	`PRESS`	confirms 100% on standard ExploitBench only
Kingy	blog test	`PRESS`	the only detailed Blender test
gist, 91 projects	community catalogue	`FORUM`	most entries unfinished

DEV Community: Oleg Żero

GPT-6 Astra's impact on CAD

Introduction

What Astra is and what it is not

Benchmarks

What they say

What they don't say

Key takeaway

Architecture and BIM

Capabilities demonstrated so far

What is not quite there yet

What existed before Astra and continues to exist

Entry level shifting

Product Design and Mechanical CAD

Capabilities demonstrated so far

What is not quite there yet

What existed before Astra and continues to exist

Hardware and PCB Design

Let's start with a few failures

What has been proven

Entry level shift

Takeaways

Money facts

Hype...?

The impact of Astra on CAD work

Can a noob in CAD do the CAD work?

Should CAD professional know AI?

The effort now shifts

References