MCP setup — MechFaber

MechFaber exposes the engine over the Model Context Protocol, so the agent you already use can drive it. The gates hold whichever model designs.

MechFaber supplies the engine, not the model. Whichever model your agent runs is the one that designs — the gates hold either way, and your design content never passes through a model provider of ours.

1. Create an account

Sign up at app.mechfaber.com. Installing the plugin does not create one, and the first tool call stops at the server without it.

There is no API key. The server speaks OAuth: the first time your agent uses MechFaber it opens a browser, you sign in, and a consent screen names your agent and lists what it is asking for. Approve it and the token is handed back automatically. Access is granted per agent, and revocable from your account settings.

2. Add the engine

Claude Code

One command installs the skill and the server together — the skill teaches the design loop, the server runs the CAD, the physics and the firmware. A skill on its own would give an agent the instructions and nothing to execute them with.

claude plugin marketplace add Argentron-Technologies/mechfaber-agent
claude plugin install mechfaber

The same works inside a session as /plugin marketplace add and /plugin install. Add --scope project to commit the plugin to a repository so everyone working in it shares one setup.

The plugin is open source and worth a look before you run it — it drives CAD on your behalf. Everything it contains is in Argentron-Technologies/mechfaber-agent: the manifest, the MCP declaration, and the skill itself.

Codex, OpenCode, Crush

Agent Skills is an open standard, so the same SKILL.md works unmodified across all of them. Copy the skill folder into ~/.agents/skills/ — Codex, OpenCode and Crush all read it — then declare the server.

Codex — ~/.codex/config.toml

[mcp_servers.mechfaber]
url = "https://api.mechfaber.com/mcp"

OpenCode — opencode.json

{
  "mcp": {
    "mechfaber": {
      "type": "remote",
      "url": "https://api.mechfaber.com/mcp",
      "enabled": true
    }
  }
}

Crush — crush.json. The oauth flag is required: Crush does not infer it, and without it every call goes out unauthenticated and the browser sign-in never happens.

{
  "mcp": {
    "mechfaber": {
      "type": "http",
      "url": "https://api.mechfaber.com/mcp",
      "oauth": true
    }
  }
}

All three also load project-local skills, so committing the skill folder to a repository gives everyone working in it the same design loop without anyone installing anything.

3. Choose a model

The gates hold whichever model designs — that is the point of them. But the geometry is the agent's own work, and that is where models differ most: laying out a machine in three dimensions, keeping a joint frame straight, noticing that a beam now runs through an actuator.

Use a frontier model for design work — Claude Fable, Claude Opus 5, or OpenAI GPT-5.6 Sol. Smaller models can drive the tools and read the verdicts perfectly well, but they tend to produce shapes the gates then reject, and the loop gets long.

4. Verify

Ask the agent to list its MechFaber tools. Every one is prefixed mech_, and they group into the stages of a design:

Stage	Tools
Parts	`mech_part_search`, `mech_part_measure`, `mech_part_cad`, `mech_part_get`, `mech_library`
CAD	`mech_build`, `mech_inspect_cad`, `mech_look`, `mech_materials`
Physics	`mech_joint_duty`, `mech_link_stress`, `mech_simulate`, `mech_simspec`, `mech_mjcf`
Electrical	`mech_wiring`, `mech_check_wiring`, `mech_power_budget`
Firmware	`mech_firmware_build`, `mech_run_firmware`, `mech_firmware_bench`
Project	`mech_project`, `mech_task`, `mech_animation`

mech_capabilities reports what this deployment can actually do, which is the honest answer when something is missing.

5. First design

Ask for a machine, not a shape. Constraints give the gates something to check:

Design a 3-DoF arm with 600 mm reach that holds 2 kg at
full extension on a 24 V pack. Use sourced actuators only,
and show me the gate log.

The agent will source and measure parts, write the build script, and run the gates. Expect it to come back having narrowed a joint range or swapped an actuator — that is the engine working, not failing. It finishes with a link to the machine in the Studio, where you can turn it, simulate it, and read its bill of materials.

Source

github.com/Argentron-Technologies/mechfaber-agent — the plugin, the marketplace manifest, and SKILL.md, which is the design loop in full. It is worth reading even if you never install it: most of it is a list of the ways machine design goes quietly wrong. LGPL-3.0.

Troubleshooting

Server not listed — restart the client; most read MCP config only at launch. In Claude Code, /reload-plugins picks up an install without one.
“Incompatible auth server” — the client could not register itself. Check it is pointed at https://api.mechfaber.com/mcp and not a stale URL.
401 on every call — the browser consent step never completed. On Crush, confirm "oauth": true is set; otherwise trigger a tool call again and approve the screen that opens.
Tools but no method — the server is connected and the skill is not. The Claude Code plugin carries both; elsewhere, check the skill folder is somewhere your agent reads.