AXLEKEYSBETAAxle Keys is operable by AI. You bring your own assistant — Claude, ChatGPT, or any MCP-compatible agent — and connect it to your projects with a single URL. It then works through the same controlled tools a person uses in Studio: reading models, writing model code, adjusting parameters, checking geometry, and producing drawings, cut lists, and renders.
Physical objects need more than a good prompt. They need context, rules, validation, and review — which is what the tools, the skills, and the draft workflow on this page are for.
Axle Keys is a hosted MCP server. Add it as a connector in Claude or ChatGPT, sign in with your Axle account, and approve — there is nothing to download and no API key to manage on this path.
https://api.axlekeys.com/mcpModel builds run on Axle's servers, so your agent can work whether or not you have a Studio tab open. If you do have one open, you'll watch the model change as the agent works.
Step-by-step setup for each app lives on the Connect page → Local tools such as Claude Code can also connect over stdio with an API key from your Account page.
Axle Keys does not run a hidden crowd of AI agents behind your back. Your agent is the one doing the thinking — Axle supplies the tools it acts through, and the knowledge it needs to act well.
What the system has to understand
The safest agent is not the most autonomous one. The safest agent knows its job, uses the right context, and makes changes in reviewable steps.
Building an object involves distinct kinds of thinking, and the skill pack covers each — in its master file or in a section of its own. These are hats your agent puts on as the work demands — not separate agents Axle runs on your behalf. Not every request needs every one: a parameter change may need none of them, a new model may walk the chain.
Establish what the user is trying to build and what already exists — the open model, the bound Systems, the files on the project. The single biggest source of bad output is an agent guessing at context that was available to read.
Turn the request into a modelling plan: object type, the main parts, how they relate in space, the build sequence, and the things that genuinely need confirming with the user before work starts.
Choose which dimensions and options become editable, with labels, safe ranges, and sensible defaults — and which stay internal. The goal is useful control, not endless control.
Author or update the model code. Read the existing model before changing it, preserve what works, and make focused changes. Geometry comes from deterministic code, so the model is built rather than guessed.
Confirm the model actually built, and measure it against the dimensions that were asked for. Axle returns the build verdict inline on every write, so an agent never has to assume its change worked.
When something fails, identify the failure and make the smallest change that fixes it — not a redesign. Read the error, inspect the current model, preserve working parts, re-validate.
A photo, a DXF, a spec sheet, a client brief — the skill pack has one section, reading-references, on turning any of them into geometry your agent can defend. It replaced three role prompts from the archived multi-agent pipeline; the craft survives, addressed to the one agent doing the work.
Turn images, sketches, screenshots, or visual references into project context — object type, proportions, visible parts, style cues, layout, likely dimensions, and areas that need confirmation. Useful when the user uploads reference images.
Read drawings, manuals, diagrams, specifications, or CAD files — extracting dimensions, constraints, material references, part names, hardware references, tolerances, and warnings.
Turn notes, emails, client descriptions, or project instructions into structured requirements — goals, constraints, object types, dimensions, user preferences, missing information, and action items.
The domain sections apply the conventions of a way of building — panels, openings, shelves, material thickness, edge banding, or extrusion profiles, cut lengths, brackets and clearances — so the model follows how that thing is actually made. Depth here grows with each System.
A skill is a reusable packet of knowledge, instructions, rules, examples, or tool guidance. Without skills, agents guess. With skills, agents follow established patterns.
The agent is the role
The skill is the knowledge
The tool is the action
The project is the context
Skills make the workflow consistent: same startup process, same routing logic, same validation approach, same System rules, same repair process. A skill is not just documentation for humans — it is operational context for agents.
Entry point for an agent session. Defines what to do at startup: identify the active model, load the sections the job needs, read existing model code before changing it, use drafts for meaningful changes, and validate before promoting.
The master file carries orientation, the build loop, and how to verify a result; four sections go deeper on one kind of thinking each — writing code, revising an existing model, designing parameters, and repairing a failed build. Each describes what to read first, what to produce, and what to do when something fails.
Describe a way of building. Open Design is the live base every model starts from; named Systems add the parts, rules, material defaults, constraints, and checks of a specific build methodology. This is what makes an agent more useful here than a generic CAD helper.
How to use the modelling API and the platform's tools correctly — the geometry API reference, view rules, and tool guidance. Keeps agents from inventing actions that don't exist.
Working patterns — a piece of furniture, a frame, a curved form, a sound parameter setup, a known repair. Agents perform better with a known pattern to follow.
Axle Keys works with physical objects, so the safe pattern is to stage a change, check it, and promote it after review — the same pattern whether a human or an agent is driving. A direct write to the live model exists and is fast; the drafts room is what makes a change reversible.
When review matters most
What agents should never do
Four layers, and it helps to keep them straight. Your agent reasons; skills tell it how this platform expects work to be done; tools are the actions it can actually take; Systems and the project supply the context those actions happen inside.
The recommended path. Add the endpoint as a connector in Claude or ChatGPT, sign in, approve — no install, no keys. Builds run server-side, so your agent works with or without a Studio tab open.
For a coding agent running on your own machine — Claude Code or your own MCP client — connect over stdio with an API key from your Account page. Same projects, different front door: the local client lists all of its tools up front, while the hosted endpoint lists a core set and reaches more through Code Mode. Codex connects to the hosted URL with an API key; if its tool calls fail on your network, switch it to the local client.
Tools are organised into rooms so the toolset stays understandable as it grows. The main rooms are below; the full list is served from the endpoint itself, so a connected agent always sees the current set rather than whatever was true when it was installed.
Orient the agent — which project and workspace is open, what the user is looking at, and which Systems are bound.
Read and write model code, create projects and models, and see the result as an image.
Adjust dimensions, counts, and options without rewriting model code.
Compose multi-part assemblies — instances, constraints, and mates between parts.
Check the build, measure against the dimensions that were asked for, and certify a model.
Stage, validate, promote, and roll back changes safely.
Define the stock a product may be built from, and assign it across parts.
Name, group, and organise the parts a model is made of.
Produce dimensioned shop drawings, lint them, and export SVG, PDF, or DXF.
Tabulate parts and nest them onto real sheet stock.
Author assembly sequences and render animation or video.
Drive the user's live Studio tab — navigate, capture the viewport, read UI state.
Upload, list, and assign roles to reference files.
Create and track longer operations — exports, renders, batch runs.
Download finished fabrication output via signed URL.
Load System rules and skills, search what the platform knows, and record lessons.
Related pages
Reusable knowledge, real validation, and reversible changes make agent-assisted CAD more reliable — not less. Connect your assistant and give it something real to build.