AI CAD for RFQ agents: Adam vs FeatureScript vs OpenSCAD

It is 09:47 on Sunday in Veldhoven. A klant has just dragged a Catia V5 assembly into the RFQ portal of a 24-person metaalbewerking shop. The pipeline does not read Catia V5. The portal returns 415 Unsupported Media Type. The klant emails the owner directly. The owner emails us.

This is the kind of edge case that decides which CAD layer you actually ship. We spent the spring evaluating three of them for a single client: a precision-machining shop that receives 1,180 STEP uploads a week from automotive, semi-cap, and biotech buyers. The RFQ agent has to read each one, estimate cost, generate a quotation, and write back inside four working hours. The question we kept circling: which parametric modelling engine sits underneath?

What the RFQ agent has to do

The agent does five things in sequence. It accepts an upload (STEP, IGES, DWG, sometimes Solidworks or Catia). It opens the file and extracts the geometry into something the costing model can reason about — features, tolerances, surface area, bend count, hole spec, threaded depths. It cross-references the buyer's NDA, the historic price list, and the current shop calendar. It writes a quotation PDF in the shop's house style. It posts the line items into the ERP.

Steps one and two are the hard part. Steps three through five are plumbing. If the geometry layer is wrong, every downstream step is wrong, and the shop loses €18,000 of revenue the first time it under-quotes a stainless 316L weldment.

We tested three layers underneath that pipeline. Each one trades the same three things against each other: per-RFQ cost at the shop's real volume, drawing retention in a way the klanten's lawyers can sign, and who picks up the phone when the parser blows up on a Sunday.

Adam, three months in

Adam launched on YC's W25 batch and hit the Hacker News front page this week. It is open-source AI CAD: a stack that treats parametric modelling as a sequence of intents and lets a model author, edit, and refactor B-rep history. We read the launch post the morning it landed and tested the engine the same day.

What we liked: the history graph is legible. A model can attach a constraint, fail the constraint check, read the error, and try again — the loop is short. The geometry kernel handles STEP cleanly, and the test corpus we threw at it (43 weldments, 88 sheet-metal parts, 12 cast housings) round-tripped without surface loss.

What we did not like: it is three months old. There is no commercial Catia V5 translator inside it. The team is small and the patch cadence is the patch cadence of any pre-Series-A open-source project. A Sunday-morning Catia bug routes to your own engineer, not to a support queue. For a sole-developer studio this is fine. For a 24-person bureau with 1,180 weekly uploads, it is a real risk that has to live in the contract somewhere.

OnShape and FeatureScript

OnShape is the opposite trade. FeatureScript is a typed language for building parametric features. The kernel is Parasolid — the same kernel underneath NX and Solid Edge — and it reads almost every neutral format you can throw at it, including Catia V5 with the Enterprise translator add-on. The API is mature. The documentation is honest. The pricing is not.

For a 24-person shop with API-grade usage, Enterprise is the only viable tier. The published per-seat costs scale fast, and a self-serve quotation agent is, formally, a shared seat — which is a conversation with their sales team, not a checkbox. We had that conversation. The number that came back was an order of magnitude over what the shop wanted to put on its CAPEX line.

The other thing is data residency. OnShape is cloud-native, which means klant drawings sit on US infrastructure. For an automotive Tier-2 supplier with German OEM customers, that is a working answer. For a defence subcontractor, it is a non-starter. The shop has both kinds of klant.

OpenSCAD plus a Claude tool-use loop

The third option is the one we did not expect to ship. OpenSCAD is a script-based parametric modeller — text in, geometry out. It does not have a B-rep kernel and it does not natively read Catia. What it does have: a nineteen-year-old codebase, a simple language a model can author and refactor reliably, and zero runtime licence cost.

The loop we built is small. Claude reads the STEP file (through a read_step tool that calls a licensed translator — we settled on CADExchanger for the format coverage), reasons about the geometry, and emits OpenSCAD source. A render tool compiles it and returns the resulting STEP plus a geometry diff against the original. If the diff exceeds tolerance, the model edits the source and retries. Typical convergence is two or three turns.

tools = [
    {
        "name": "read_step",
        "description": "Extract features, holes, bends, threads from a STEP file.",
        "input_schema": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"],
        },
    },
    {
        "name": "render_scad",
        "description": "Compile OpenSCAD source to STEP. Returns the path and a geometry diff vs the reference.",
        "input_schema": {
            "type": "object",
            "properties": {
                "source": {"type": "string"},
                "reference_step": {"type": "string"},
            },
            "required": ["source", "reference_step"],
        },
    },
]

The OpenSCAD source itself is the artefact we hand back to the shop's engineer for review. It is text. It diffs. It versions in git. When a klant uploads a near-duplicate of last month's part, the model retrieves the prior source and edits it instead of starting over.

// quote-2026-06-14-A77.scad — sheet-metal bracket, 2mm SS304
module bracket(length, width, hole_d, bend_angle) {
    difference() {
        union() {
            cube([length, width, 2]);
            translate([length, 0, 0])
                rotate([0, -bend_angle, 0])
                    cube([30, width, 2]);
        }
        translate([length/2, width/2, -1])
            cylinder(h = 4, d = hole_d, $fn = 64);
    }
}

bracket(length = 120, width = 40, hole_d = 8.5, bend_angle = 90);

Per-RFQ cost at 1,180 a week

The shop runs roughly 4,720 RFQs a month. We measured three months of real traffic across all three stacks and the spread is wider than the brochures suggest.

The Claude-plus-OpenSCAD loop landed at €0.04 to €0.07 per RFQ in model tokens, using Sonnet 4.5 for geometry reasoning and a small Haiku pass for triage. CADExchanger sits on a flat licence, so the translator cost amortises to under a cent at this volume. Total: under €350 a month, give or take traffic spikes.

Adam, self-hosted on a single workstation-class GPU, came in between €600 and €900 a month including electricity and a depreciation slice on the box. That is fine, but the cost is in the hardware floor, not in the per-call. If volume halves, you still pay the floor.

OnShape Enterprise, in the shape we would have needed, was over €4,000 a month before any API quota uplift. Their per-seat model is built for a human engineering team, not a server-side agent that is awake at 02:00 quoting a Korean buyer's STEP file.

Drawings under NDA

Half the shop's klant base routes drawings under NDA. Three of the larger ones — names we cannot mention — write a hard data-residency clause into the contract: drawings stay inside the EU, and the right to inspect the pipeline sits with their procurement team, not their lawyer.

The Claude loop runs on Anthropic's EU endpoint for the model calls; the renderer and the CADExchanger CLI run on the shop's own hardware in a rack in Eindhoven. Drawings cross one network boundary and come back. Source code, OpenSCAD files, and quotations sit in a git repo the shop owns outright. We can show a klant the exact bytes that left the building, when they left, and to which IP.

Adam, self-hosted, matches that. OnShape, by design, cannot. That single fact disqualified the cloud option for two of the shop's top-five klanten before we got near the pricing conversation.

On-call at 09:47 on a Sunday

This is the question most CAD evaluations skip. The Catia V5 upload that triggered this whole comparison is not a hypothetical. It happens roughly twice a quarter at this shop and the answer cannot be "wait until Monday."

OnShape's answer: their support queue. Response targets are documented. The escalation path exists. We have seen it work and we have seen it not work. Twice during the pilot, the ticket sat for sixteen hours.

Adam's answer: GitHub Issues, the YC Slack, or your own engineer. Three months in, this is not a complaint — it is a fact about the maturity of an open-source project at this stage. If you ship Adam, you ship the team that maintains it for you.

OpenSCAD's answer: the file is text. The model reads the error, rewrites the script, and retries. For exotic formats like Catia V5 the bottleneck is the translator, not the modeller, and CADExchanger has a real support contract with a real European phone number. The Sunday-morning failure mode degrades to: the agent emails the buyer, asks for a STEP export, and quotes eighteen minutes later when they reply. That is a fine failure mode. It does not lose the deal.

What we shipped for the Veldhoven shop

We ended up with the OpenSCAD plus Claude tool-use loop, with CADExchanger doing format translation and a small private RAG index over the shop's twenty years of historic quotations. The agent quotes around 94% of incoming RFQs without human review and routes the rest to a senior estimator with a pre-filled draft. The shop's throughput on quotations went from three per estimator-day to twenty-eight, and the senior estimator now spends his mornings on the parts that actually need a brain.

When we built this AI agent for the metaalbewerking shop, the thing we kept hitting was that the Catia V5 translator was the actual product, not the model. We ended up budgeting more for CADExchanger than for Claude, and the agent only became reliable once we treated format coverage as a first-class line item, not an afterthought.

If you are evaluating a CAD layer for your own RFQ pipeline this week, here is the five-minute audit: count the unique CAD formats you received last month, multiply by the number of klanten using each, and ask your vendor what their answer is for the smallest format on that list. If the answer is "we'll get back to you," you have your shortlist.