- —The Axle language — a program per workspace, Configure and Make first
- —Build out the first named Systems beyond Open Design
- —Deepen the knowledge that makes a System worth choosing
- —Admit Keyholders and work through real projects with them
- —Sharpen drawings, cut lists, and nesting against real shop output
- —Usage metering and the plan structure behind launch
- —Expand documentation to match everything that now ships
How Axle Keys
is being built.
Axle Keys is being built in public, one practical layer at a time. This page is the only place on the site that describes things that don't exist yet — everywhere else states what works today.
The modelling core, the fabrication outputs, and the agent endpoint are built and in use. What's still ahead is the knowledge that makes each System worth choosing, and the public spaces where finished models meet buyers.
Systems, and
the people using them.
The model loop works: tell your own agent what to build, or import an object; shape it, verify it, and take it out as drawings, cut lists, exports, or a configurator — in Studio or over MCP. The current work is the layer that makes the output specific: Systems that carry how a thing is genuinely made, proven against real projects with the first Keyholders rather than declared finished on a marketing page.
Ten phases.
Foundation
● Complete- —Studio environment — 3D viewport and a parametric CAD engine in the browser
- —Geometry generated by deterministic code from parameters, not by a model guessing shapes
- —Authentication, accounts, and project storage
- —Platform infrastructure on Cloudflare
- —Public website and documentation
The platform is live and the modelling engine is real. Everything after this builds on it.
Studio — the model loop
● Complete- —Tell your own agent what to build, or import an object, and get a real parametric model back
- —Five workspaces: Create · Assemble · Motion · Configure · Make
- —Parameters you can change without rebuilding the model from scratch
- —Multi-part assemblies, instances, and constraints between parts
- —Dimension checking against what was actually asked for
- —Version history, validation, and recoverable delete
- —STEP import — bring existing geometry in as a reference and preview it
This is the working core of the product today. It is why the rest of the roadmap is worth building.
Outputs — from model to shop
● Complete- —Shop drawings — dimensioned projected views, exported as SVG, PDF, or DXF
- —Cut lists and sheet nesting on real stock, with offcuts and quantities
- —Materials — a product stock palette assigned across parts, with real surfaces
- —Fabrication exports — STEP, STL, DAE
- —Motion — assembly animation and rendered MP4 video
- —Embeddable configurators — live 3D on your own site, no login and no AI at runtime
One model, many artifacts. A finished model produces the files a shop actually builds from.
Agents and the hosted endpoint
● Complete- —A single hosted MCP endpoint — add Axle to Claude or ChatGPT with one URL
- —OAuth sign-in, no local install and no API keys on the hosted path
- —Agents read models, write model code, adjust parameters, and validate geometry
- —Builds run server-side, so an agent works with no browser tab open
- —Drawings, cut lists, and renders available to agents as well as people
- —Every write versioned, validated, reversible, and recorded with its reasoning
People work in Studio, agents work over MCP, and both drive the same model.
Systems
● In progress- —Open Design — the live base knowledge every model builds on today
- —Systems as composable context packs bound to a model
- —Cabinet and casework — panel logic, sheet goods, edge banding, shop conventions
- —T-slot extrusion — profiles, hardware, cut lengths, assembly summaries
- —Flat-sheet and laser — joinery, kerf, and nesting rules
- —Closet and storage — shelf spacing, clearances, load limits, hardware sizing
- —Snap-fit and print — tolerance classes, retention force, print orientation
- —System-specific validation and fabrication rules
A System is a build methodology captured as real context — parts, rules, constraints, materials. Open Design works today. A named System is only worth releasing when it knows enough to be genuinely better than starting from scratch, and that is the work in progress.
Access and launch
● In progress- —Invitation-only beta — access by Keyholder code
- —Waitlist and application process ahead of launch
- —Usage metering and plan structure
- —Public pricing once the plans can be explained clearly
Access is deliberately narrow while the product is proven with real work.
The Axle language — one program per workspace
● In progress- —Create already works this way: an agent writes a short program, Axle builds it and returns the verdict on the same call
- —Motion — a program that directs the whole show from the model's own facts: camera, joints, visibility, captions
- —Make — a program that composes the drawing pack, cut list and build instructions, with drafting conventions as the defaults
- —Assemble — a program that places instances and mates from anchors and joints, and derives how each part arrives
- —Configure — a program that decides what a buyer may change, and a contract for what a published page may do
- —Every program stored with what it made, re-run when the model changes, and the hand edits walked around
Create was given a language and every other workspace was given buttons. A legible drawing, a build sequence a person can follow, an animation that explains itself, a parameter panel that fits the buyer — these are the outputs an agent is worst at improvising and a workshop is best at knowing. The language moves that knowledge into Axle, so the agent writes ten lines and the workshop does the craft.
Publishing — Exhibition and Showroom
○ Next- —Exhibition — a public space to browse, discover, and open configurable models
- —Showroom — branded product lines customers configure within limits you set
- —Customer inquiry and lead flow from a published configuration
The embeddable configurator and a model's own public page at axlekeys.com/models/… already ship, so the engine and the first public surface exist. What is missing is discovery — the places a buyer finds the model without ever opening Studio or being handed a link.
Community and ecosystem
○ Later- —Public System authoring
- —Creator profiles and attribution
- —Remixes and forks
- —Public REST API with agent permission policies
- —Usage analytics and dashboards
- —More object families — robotics, motion, structural
The efficient factory
○ Later- —Measure what each finished object costs in intelligence — calls, tokens, repairs and time, per workspace
- —Find the reasoning an agent repeats and move it into a System, a rule, a default or a validator
- —A component library an agent can navigate by fit — thread, hole pattern, load, mating part — not by loading it all
- —When an agent solves something new, keep the solution as a reusable System rather than a one-off file
- —Only once that is measured: ask whether known work needs a frontier model at all
Every CAD tool will let you bring your own model, so the model is not the advantage. The advantage is how little intelligence a correct, buildable object costs. Other tools give an agent better CAD tools; Axle Keys aims to give it less CAD work. This phase waits on the language and the Library — it is measured, not guessed.
Now, next,
later.
- —Exhibition — public browsing and discovery
- —Showroom — branded product lines for shops and businesses
- —Lead and inquiry flow from a published configuration
- —Public pricing and open signup
- —Public System authoring
- —Creator profiles and attribution
- —Remixes, forks, and community tools
- —Public REST API
- —Agent permission policies
- —More object families — robotics, motion, structural
- —The efficient factory — measure the intelligence each object costs, then move repeated reasoning into the workshop
How decisions
get made.
A few principles that guide what gets built and in what order.
One System first
One complete, working, well-documented System is worth more than five half-built ones. A System is only released when it knows enough to beat starting from scratch — which is why Open Design ships today and the named Systems are still listed as work in progress.
The boundary is the value
Every decision about what the platform can and cannot do is a product decision. Systems work because they have rules. A good configurator exposes the decisions that matter and protects the technical relationships underneath.
Designed to be called
Every feature is evaluated against whether it makes the platform more callable — by people in Studio, by developers via API, and by agents via MCP. Callability is the long-term product. Agents are more useful when they work inside structure.
Follow
the build.
The roadmap will keep changing as the Systems become stronger and real users push models from idea to output. That is the point of building it in public.