frank

Plan, build, and review 3D models with Claude Code — through a modeling MCP (Rhino or Houdini).

 Claude Code plugin · 5 skills · 6 agents

frank is a Claude Code plugin that turns a modeling MCP server into a disciplined design partner. It plans the form before touching geometry, builds it as a re-runnable parametric generator, reviews the result against your reference — and it's frank about what's wrong with your geometry.

Honest about your topology.

Why

LLM-driven CAD usually fails the same ways: hallucinated API calls, magic-number scripts you can't tune, geometry that duplicates or stomps your existing model, and "looks done" with no actual verification. frank encodes the opposite as a workflow:

• Parametric, not one-off — every build is a named parameter block you can re-run and tune.
• Idempotent & scoped — rebuilds clear only their own layer/namespace; your existing model is never touched (a foreign-object-count invariant is checked every run).
• Grounded, not guessed — primitive signatures are confirmed live from the MCP before code is emitted, not recalled from memory.
• Verified, not vibes — a capture → compare → adjust loop with geometric assertions and your sign-off, not "looks good."
• Compounding — every solved gotcha gets written down so the next model doesn't repeat it.

Requirements

frank drives a modeling application through an MCP server — it does nothing on its own. You need:

1. Claude Code (CLI, desktop, or IDE).

2. A modeling MCP server connected to Claude Code — one of:

   Modeler	MCP server	What frank needs
   Rhino	a RhinoMCP server, e.g. jingcheng-chen/rhinomcp	mcp__rhino__* tools available; Rhino running with its MCP addon started
   Houdini	capoomgit/houdini-mcp	mcp__houdini__* tools available; Houdini running with the socket server started — see docs/houdini-setup.md for a hardened, step-by-step setup (the upstream has a few install gotchas frank documents and patches)

   Confirm a server is live with claude mcp list — you should see rhino or houdini as ✓ Connected.

frank is tool-agnostic: the same plan → build → review flow drives whichever modeler is connected, by loading that tool's reference pack.

Install

claude plugin marketplace add robotnealan/frank      # add the marketplace from GitHub
claude plugin install frank@frank-marketplace        # install the plugin

Then run /reload-plugins in Claude Code to activate the skills and agents — no restart needed. Verify with:

claude plugin details frank@frank-marketplace        # lists 5 skills + 6 agents

/reload-plugins may print 0 skills — that's a delta counter (zero newly added), not a failure; the skills are active. See the install learning for this and other gotchas.

git clone https://github.com/robotnealan/frank
claude plugin marketplace add /path/to/frank         # add by local path
claude plugin install frank@frank-marketplace

Re-run /reload-plugins after editing any skill or agent to pick up changes. The plugin's marketplace.json uses "source": "./" (plugin at the marketplace root) — on Claude Code a relative source must start with ./; bare "." is rejected.

Quick start

With a modeling MCP connected, the workflow is five slash commands:

/frank-setup     # verify the connection; record units, tolerance, existing layers/networks
/frank-plan      # design the form: artifact type, fidelity, primitives, the param block + assertions
/frank-build     # emit + run an idempotent, scope-isolated parametric generator; capture the result
/frank-review    # capture → compare → adjust against your reference, with your sign-off
/frank-compound  # record a solved gotcha so the next model doesn't rediscover it

You don't have to use all five — /frank-build "a parametric helical coil" works on its own. frank-plan and frank-review add rigor for harder or reference-driven forms.

Skills

Agents

Six agents ship today. frank-fabrication-reviewer (wall thickness, overhangs, watertightness, undercuts) is planned alongside knowledge/fabrication.md.

How it works — three layers of knowledge

frank keeps durable craft separate from volatile API:

1. Canon (knowledge/*.md) — what good looks like (named param blocks, scope isolation, verification discipline). Authored with citations; doesn't go stale.
2. Reference packs (references/<tool>-mcp.md) — which calls and which verified policies on this tool. The only place tool-specific detail lives.
3. Live grounding — the *-docs-researcher agents confirm exact signatures in-session, so the canon never bakes an API that can rot or hallucinate.

And it compounds: every solved gotcha is written to docs/solutions/ (via /frank-compound) and retrieved before future work, so the system gets smarter with use.

Tool support

Contributing

Issues and PRs welcome. frank is designed to compound: if you solve a modeling or tooling gotcha, capture it with /frank-compound (or add a docs/solutions/YYYY-MM-DD_<slug>.md learning by hand) so the next person inherits it. Adding a new modeler is mostly a new references/<tool>-mcp.md pack plus a *-docs-researcher agent — the skill spine is already tool-agnostic.

License

MIT © Robert Nealan