PartMode: browser CAD where a typed agent edits the same schema-5 document you do
Open-source, local-first 3D parametric CAD that runs in the browser for people and permissioned typed agents, powered by OpenCascade WASM.
At a glance
- What is it?
- PartMode is an AGPL-3.0 parametric CAD application that runs OpenCascade compiled to WebAssembly inside the browser, with a documented path for permissioned agents to commit changes against the same document revision a person is editing. The interesting part is the authority model, not the feature list.
- Who is it for?
- Adopt PartMode if you want parametric B-rep modelling in a browser tab with no install, and you are willing to accept that hosted agent access means an account, a revocable key, a signed-in tab and visible per-session approval. Do not adopt it if you need a headless CAD service that survives restarts without committed documents, or if you need to delete an individual headless project.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 29 days ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem is parallel automation state, not browser CAD
Plenty of projects put a CAD kernel in a browser tab. PartMode's stated premise is narrower: human edits and agent edits should go through one canonical document model and one exact kernel rather than two representations that drift. The README frames it as changes using "the same canonical document model and exact kernel instead of parallel, opaque automation state." That is a design constraint, and it explains most of the unusual decisions elsewhere in the project.
The audience follows from that. It is for mechanical design work that fits in a browser session, and for people who want a typed agent to do revision-safe edits on a project they are looking at, with the ability to reject, pause, disconnect or revoke. Anonymous browser CAD needs no account at all. Everything hosted is opt-in and separate. If you only want to draw a bracket and export STEP, the agent machinery is inert.
Two authority paths over one schema-5 document
The architecture diagram in the README shows a fork that matters. A human browser UI writes to a browser-local schema-5 document. A typed agent client reaches an authority decision made by the account owner, and that decision leads either to a browser-approved local session or to a headless-granted session. The first path writes to the browser-local document. The second writes to a separate account-owned schema-5 document. Both feed the same OpenCascade WASM kernel, which produces exact B-rep evidence, which in turn feeds browser drawings or headless STEP export.
The two paths are not the same storage with different front ends. The README is explicit that the headless grant "is a separate storage and authority choice, not an automatic extension of browser access." A key authenticates an agent but does not by itself grant CAD authority. In the browser-approved case the agent inspects current state, builds a detached preview, and commits only against the matching document revision. The person approves the project-scoped session visibly.
The three.js scene is described as a view of the kernel result, not the source of truth. That distinction is what separates this from mesh-first browser modellers: the shaded viewport can be wrong or stale without the underlying solid being wrong.
Running it locally takes four commands and Node 22.13
The README gives the sequence directly. Node.js 22.13 or newer is required.
git clone https://github.com/BOMWiki/partmode.git cd partmode npm ci npm run build npm start
The app then serves at http://127.0.0.1:4401. The README states that browser-local CAD at that address requires neither an account nor an external service, which is the claim worth verifying first if local-first is why you are here.
For contributors there is a focused gate, npm run ci:gate, which the README says type-checks and builds the release, verifies static and runtime manifests, and exercises the local HTTP, account, identity, MCP, cloud and entrypoint contracts. CAD, kernel, assembly, export and visible UI changes additionally require the affected smoke:* checks. A broader blocking gate runs through npm run release:gate, with professional and nightly matrices kept separate.
Connecting an agent is a client-side command. For Codex, the README shows:
codex mcp add partmode --url https://partmode.com/mcp --bearer-token-env-var PARTMODE_AGENT_KEY
The key is created from the account's Agent access page and belongs in the secret environment used to launch the MCP client. The README warns against pasting it into a prompt, URL, command argument or repository file. Note the config key: the bearer token is read from the environment variable named by --bearer-token-env-var, so the literal token never appears in the client configuration.
The relay is bounded memory, not encrypted storage
This is the part a security reviewer should read twice. Approved commands and results cross the hosted relay over HTTPS and, per the README, remain only in bounded process memory. There is no offline queue. The relay is not end-to-end encrypted. The browser project itself is not stored on the relay.
So the trust model is: the browser holds the project, the relay holds transient traffic, and the account owner holds the revocable key plus the approval decision. If your threat model requires end-to-end encryption between agent and browser kernel, this design does not provide it, and the documentation says so rather than implying otherwise.
Headless has its own hard edges. Live headless sessions are key-bound, expire within one hour, and do not survive a service restart. Only committed headless documents are durable. Committed records survive session expiry, key revocation, restarts and deployments, and persist until account deletion, but the README states there is no individual project-delete control yet. Headless execution also has no visible Studio and a narrower artifact surface, with STEP as the current dedicated export path. If you need unattended batch CAD with per-job deletion and a wide export surface, that combination is not here.
Interchange is broad on import, narrower on drawing export
The interchange row of the capability table lists editable PartMode project bundles, STEP import and export, and STL, AMF and 3MF mesh exports. Drawings are the asymmetric case. The README says exact OpenCascade hidden-line views are produced, and SVG and PDF sheets can carry document-owned dimensions, tolerances, notes, symbols and tables. DXF, by contrast, exports "a restricted R12 orthographic or sketch geometry subset."
That restriction is worth planning around. If your downstream process consumes DXF with anything beyond orthographic or sketch geometry, you are exporting to a format the project itself describes as a subset, and you should test your specific geometry before assuming a round trip. The mesh exports are mesh exports: useful for printing and viewing, not for re-entering a parametric history.
There is also a scoping caveat the README volunteers: templates are editable schema-5 starting projects rather than decorative meshes, but "exact capability coverage varies by template," and a failed rebuild is reported rather than silently accepted as valid geometry. The second half of that sentence is the more useful behaviour. A CAD tool that reports a failed rebuild instead of showing stale solids is doing the right thing, though it does mean a template can open and then refuse to rebuild.
The capability surface is per-release, so query it
The README states plainly that live cad_capabilities output is authoritative for the exact operations and schemas a running release supports. That is a deliberate refusal to promise a fixed feature set in prose. It also means any review, including this one, cannot tell you which operations your build exposes; the capability table describes areas such as constrained sketches, feature history, configurations, patterns, holes, threads, sheet metal, assemblies with mates and exploded views, mass properties and inertia tensors, but the per-operation truth lives in the running release.
Treat that as a first-step instruction rather than a footnote. After connecting an MCP client, call cad_capabilities before constructing anything, which is what the README tells you to do. If a feature you need is absent from that output, it is absent from that build regardless of how the table reads.
The same applies to the agent tooling: the README lists hosted MCP tools for capabilities, inspection, queries, detached previews, revision-safe commits, browser artifacts and opt-in server-headless STEP workflows. Revision-safe commits are the mechanism that makes the shared-document claim real, since a commit against a stale revision should not land.
Against FreeCAD and the OpenCascade desktop stack
The obvious comparison is FreeCAD, which also builds on OpenCascade and also offers parametric modelling with a feature tree, assemblies and drawings. The difference in approach is where the kernel runs and where the document lives. FreeCAD runs the kernel natively on your machine and stores files on your filesystem, with a Python console as the automation surface. PartMode compiles the kernel to WebAssembly, keeps the document in browser storage by default, and exposes automation as typed, permissioned MCP operations against the same schema rather than as a scripting language over the same objects.
That trade cuts both ways. FreeCAD's Python console lets you write arbitrary automation without an account, a relay or a session expiry. PartMode's typed operations are narrower by construction, which is precisely what makes the approval and revision-matching model possible, and precisely what stops an agent from doing something the schema does not describe. If your automation needs to reach outside the typed operation set, this is the wrong tool and a scriptable desktop kernel is the right one.
The other difference is durability. A FreeCAD file is a file. In PartMode, browser-local projects live in browser storage with recovery history, and durable server-side documents exist only on the committed headless path.
Licence and the cost of tracking a moving snapshot
PartMode is AGPL-3.0. The README says it is free to use, inspect, modify and self-host under that licence. The practical consequence of AGPL for a networked application is that offering a modified version to users over a network carries source-availability obligations. That is a statement about the licence text, not advice about your situation; if you plan to host a modified PartMode for others, get your own reading of the AGPL and of what counts as corresponding source in your deployment.
The maintenance picture visible in the material is a fast-moving source tree with snapshot-style releases rather than semantic version tags. The most recent release listed is source-snapshot-2026-08-11, and the repository shows a push on 2026-08-17. Snapshot naming tells you the project is publishing states of the tree, which makes pinning a specific snapshot the sensible unit of upgrade rather than tracking main.
Upgrade cost concentrates in two places. First, the document schema: the README refers to schema-5 documents, and a schema change is the kind of thing that affects stored projects. Second, the capability surface, which the README already says varies per release and must be read from cad_capabilities. There is no separate migration tooling described in the supplied material, so the honest position is that migration behaviour across schema versions is not something this material lets me confirm. Run npm run ci:gate against the snapshot you intend to deploy, and treat the smoke:* checks as the gate for any change that touches CAD, kernel, assembly, export or visible UI.
Editorial conclusion
Adopt PartMode if you want parametric B-rep modelling in a browser tab with no install, and you are willing to accept that hosted agent access means an account, a revocable key, a signed-in tab and visible per-session approval. Do not adopt it if you need a headless CAD service that survives restarts without committed documents, or if you need to delete an individual headless project. Before committing, run npm run ci:gate against the snapshot you intend to use, call cad_capabilities on the running release to see which operations that build actually supports, and read docs/help/agents.md for the permission and storage boundaries.
Community notes