From an empty sheet to a released cutlist
How Wiring Studio models a harness, what it derives from that model, and how each view feeds the bill of materials and the cutlist.
Chapters
Last updated 15 September 2026
The MCP server
The MCP server lets an AI assistant work inside your Wiring Studio account. Point Claude, ChatGPT, Codex or any other MCP client at one hosted address, sign in once in the browser, and the assistant can list your projects, read a sheet, place components, wire cavities, run the design rule checks and look at what it has drawn — as you, with exactly the access you already have.
What it is
The Model Context Protocol is a standard way for an AI assistant to call tools inside another application. Wiring Studio runs an MCP server at a fixed address, so there is nothing to install, host or keep running — you give a client the address, sign in, and the assistant has 59 tools covering the same project data you work with on the canvas.
It acts as you. Every call is made under your own account, so the assistant sees the workspaces you belong to and nothing else, and its edits are your edits: they appear on the canvas immediately, and for everyone else in the project, through the same real-time sync a team works through and exactly as if you had drawn them yourself. Workspace, project and sheet are arguments on the tools, so the assistant has to say which sheet it is working on rather than inheriting whatever you happen to have open.
There is no API key to generate and no token to paste anywhere. The first time a client contacts the server it is turned away and told where to sign in, registers itself, and opens a browser window for the same Wiring Studio sign-in you use everywhere else. The client keeps the result — you never handle a credential.
What you can do
The 59 tools fall into ten groups. The read tools return structured data an assistant can reason about; the write tools change the project.
| Group | Tools |
|---|---|
| Workspaces | list_workspaces |
| Projects and sheets | list_projects, get_project, create_project, rename_project, create_sheet, rename_sheet, set_project_settings |
| Parts library | search_parts, get_part, list_manufacturers, upsert_part |
| Components | get_sheet, add_component, update_component, delete_component, set_pin_layout, set_mating_connectors, add_extra_part, update_extra_part, delete_extra_part |
| Wiring and pins | list_wires, connect_wire, update_wire, delete_wire, set_twisted_pair, clear_twisted_pair, rename_network, set_pin, fill_pins, get_pin_config |
| Cables, shielded cables and labels | list_cables, add_cable, update_cable, delete_cable, set_cable_layers, list_shielded_cables, add_shielded_cable, update_shielded_cable, delete_shielded_cable, add_label, update_label, delete_label |
| Reports and rules | get_bom, get_cutlist, run_drc, list_drc_rules, set_drc_rules, auto_layout, derive_cables_from_wires |
| Layout | get_layout, move_components, transform_components, set_route, split_cable, scale_layout |
| Assemblies | insert_assembly, save_as_assembly |
| Screenshots | screenshot_sheet |
Names, arguments and descriptions travel over the connection itself, so the list your client shows you is the authoritative one. The table above is a map of the ground it covers, not a schema to code against.
What to ask for
The tool list is a map, not a suggestion. What follows is the work people actually hand over — the jobs that are slow because they are wide rather than difficult, where a person is the bottleneck only because somebody has to walk every row. Each one names the tools it leans on and the thing that will trip it up. The last two are not edits at all: they are questions you would otherwise answer by tracing the drawing by eye.
Fill the library from a catalogue
Getting a parts library populated is the wall most harness tools hit on day one: cavity counts, contact gauge ranges, seals and prices, typed in from supplier PDFs. Point an assistant at the catalogue or datasheet instead and it can write the parts in directly with upsert_part, one per part number, across any of the sixteen categories. Only the part number, category and manufacturer are required, and it needs no paid plan — a Free personal workspace can take a full catalogue.
upsert_part replaces a part, it does not patch it. Anything left out goes back to its default, so a price-only update on a twelve-way connector silently resets it to one cavity and clears its mates in every project that used it. Read the part with get_part first and send the whole set of properties back. Part images and contact-arrangement drawings are not part of the tool surface at all, so an imported catalogue arrives without them.
Replace a part that has gone end of life
When a connector is discontinued the hard part is not choosing the replacement, it is finding every place the old one is used before one slips through into production. An assistant can walk list_projects, get_project and get_sheet, then repoint each use in turn: update_component for components, update_wire for wires, set_pin and fill_pins for contacts and seals, update_cable for coverings, update_label, update_extra_part and update_shielded_cable for the rest.
There is no single find-and-replace call, and each of those objects holds its own part reference, so a widely used part means one write per use against a limit of sixty calls a minute. Repointing a component changes which part it is, not how many cavities it has — swap a twelve-way for an eight-way and the wires on the cavities that no longer exist survive as errors. Finish with run_drc and fix what it names.
Build a project from your own spreadsheet
Excel import reads a workbook cold and infers what the columns mean. Your own wire list does not need inferring — you already know that column D is the cavity and that a dash in the reference means a splice. Write those conventions down once as a prompt or a saved skill, and an assistant can read the file on your terms and build the project with create_project, add_component, connect_wire, fill_pins, add_cable and add_label.
Parts have to exist before the components that use them, so run the catalogue pass first. create_project already returns a first sheet — calling create_sheet for it wastes a call and fails outright on Free, which allows one sheet per project. A project still being built by Excel import is read-only until it finishes, and get_project reports that as importing.
Re-price a library and re-quote
Prices go stale between revisions and a bill of materials retyped by hand goes stale faster. Price lives on the library part, which is shared by every project in the workspace, so one upsert_part per part propagates everywhere. get_bom and get_cutlist then report what the harness costs, and set_project_settings carries the per-project priceMultiplier and cutlistMultiplier that turn cost into a quote.
search_parts returns at most a hundred parts and has no pagination, so ask for one category at a time rather than for the library. The part-no-price and part-no-number checks are the quickest way to find what is blocking a clean quote — both look at the whole project, not one sheet.
Make the naming consistent
Signal names drift: a net gets renamed on one sheet and not the next, or a convention changes halfway through a programme. rename_network is project-scoped rather than sheet-scoped, so one call renames every wire in the net wherever it lives and reports how many it touched. Pair it with list_wires to audit first. It is worth running after any pass that repoints wire endpoints, since moving an end does not re-derive the net name.
Fix what the design rule checks find
Faults found at the crimp bench cost far more than faults found at the desk. run_drc returns every violation with its rule, severity, message and subject, and most rules have an edit behind them: cable-no-length goes to update_cable, contact-missing to fill_pins, part-no-price to upsert_part, cable-no-route to set_route or auto_layout. Ask for a pass and the assistant can triage the list and fix the ones that are mechanical.
Violations are located by name rather than by an internal id, which is the same vocabulary the write tools take. Wire subjects spell the endpoint with the cavity label, though, so fixing one usually needs get_pin_config to map the label back to the cavity number. At most a hundred violations come back in one call — the counts stay complete and truncated says when the list was cut — and a project over six hundred components is refused, because that check belongs in the app.
Reuse a sub-harness across programmes
Most teams redraw the same power branch or the same ground stud arrangement on every programme. save_as_assembly snapshots named components — or a whole sheet — with their wiring, pin assignments, shielded cables, labels and extra parts intact, and insert_assembly deep-copies it into any project at a position you give, reporting anything it had to rename to avoid a collision. Saving one counts against the reusable-component allowance on your plan, and inserting an assembly into a different workspace leaves its part references unresolved.
Turn a wire list into a drawing
A schematic that is electrically complete is still not something a bench can build from. derive_cables_from_wires creates a design edge everywhere wires run but no cable is drawn, add_cable and update_cable put real lengths on them, and scale_layout re-flows the sheet so what is drawn is proportional to what will be cut. auto_layout rearranges for legibility, split_cable inserts a branch point or an inline splice partway along a run, and screenshot_sheet shows you — and the assistant — what came out.
Trace a colour-coded wire
On the bench the question is never abstract: somebody is holding a red wire with two white bands and wants to know where the other end lands. list_wires returns every wiring edge on a sheet with both endpoints as a component name and a cavity number, along with the wire part it uses and the marking bands on it, so an assistant can find the run and tell you where it goes. get_pin_config turns the cavity number into the label printed on the connector, and screenshot_sheet points at it on the drawing. Wire colours and marking covers how the colours are set in the first place.
Colour is not on the wire, it is on the library part. list_wires gives you wirePartNumber, and the colour is the hex value in props.wire.color that get_part returns. search_parts matches part numbers, descriptions and manufacturers rather than colour, so asking for the red wire works when your wire parts say red somewhere in their description and needs the part number when they do not. The bands in colorCodePartNumbers are separate heat-shrink parts, and the colour on a twisted pair's group is the pair's own, not either wire's.
Answer what a network connects
A net is the question people actually ask of a harness: what else is on CAN-H, what shares this ground, what goes dark if this cavity is wrong. list_wires carries networkName on every edge, so an assistant can group a sheet's wires by net and read the members straight off it, with both endpoints already named. get_sheet gives each connector its mate, which is how a net leaves one sheet for the next.
There is no single call that returns a network. list_wires shows one sheet at a time, so a net that crosses a mated connector pair means one call per sheet and stitching the halves together — a mate joins pin to pin by number, including across sheets. Wires that were never named come back with networkName null and have to be walked endpoint to endpoint. Network names are not unique either, so two unrelated nets can answer to the same one. rename_network is the single net-wide operation, and it reports how many wires it touched.
Before you start
- Any plan can connect, Free included. There is no separate purchase and no MCP seat.
- The assistant sees every workspace you belong to, personal and organisation alike. It cannot reach a workspace you are not a member of.
- Writing into an organisation workspace needs the Team plan. Below it the organisation is read-only over MCP, exactly as it is in the app, and every edit is refused.
- It reads and it writes. Creating, editing and deleting are all available, and none of it asks you to confirm a second time.
- Your plan limits still apply to what it creates, refused in the same way and for the same reasons as in the app. See Pricing and plans.
- A project still being built by Excel import is read-only until that import finishes.
The client you connect is third-party software running under someone else's terms, and your project data goes to whichever model provider is behind it. What Wiring Studio itself records is set out in section 1.5 of the privacy policy, and the services involved are listed on the subprocessors page.
Edits made over MCP are immediate. There is no dry run and no review step — the assistant writes straight into the live project, and everyone else in it sees the change at once. Point a client at a scratch project first and learn how it behaves before letting it near real work.
Connect Claude
Every client needs the same one thing, the server address.
https://mcp.wiring.studio/mcpClaude Code
claude mcp add --scope user --transport http wiring-studio https://mcp.wiring.studio/mcpUse --scope project instead and the server is written into a shareable .mcp.json in the repository, which colleagues approve and sign into with their own accounts.
{ "mcpServers": { "wiring-studio": { "type": "http", "url": "https://mcp.wiring.studio/mcp" } } }Claude Desktop and claude.ai
Custom connectors are available on Free, Pro, Max, Team and Enterprise, and Free allows one of them. On Team and Enterprise an owner adds the connector under Organization settings ▸ Connectors first; everyone else then clicks Connect and signs in as themselves.
Claude reaches the server from Anthropic's cloud rather than from your own machine, which is why there is nothing to run locally and why the address has to be a public one. It is.
Connect ChatGPT
ChatGPT
Plus and Pro can turn developer mode on themselves. On Business, Enterprise and Edu a workspace admin has to enable it first, under Workspace Settings ▸ Permissions & Roles. Connectors in ChatGPT are available on the web only.
ChatGPT can only connect if its connector registers itself with our sign-in service the way the other clients on this page do, and that is not something we can confirm from our side. Treat these steps as a preview until it is: if the sign-in window never opens, the fault is the handshake rather than anything you have typed, and the other clients here are the dependable route in the meantime.
Codex CLI
codex mcp add wiring-studio --url https://mcp.wiring.studio/mcp
codex mcp login wiring-studioThe first command writes the entry below into ~/.codex/config.toml; you can equally write it by hand and then run the login command.
[mcp_servers.wiring-studio]
url = "https://mcp.wiring.studio/mcp"Other MCP clients
Any client that speaks streamable HTTP MCP and OAuth 2.1 with dynamic client registration works. Give it the server address and it arranges the rest itself — no headers to set, no keys to store, and nothing to configure beyond the URL.
{ "mcpServers": { "wiring-studio": { "url": "https://mcp.wiring.studio/mcp" } } }- Cursor — the shape above, in ~/.cursor/mcp.json for every project or .cursor/mcp.json for one.
- VS Code — .vscode/mcp.json, where the top-level key is servers rather than mcpServers, and the entry carries type: http beside the URL.
- Windsurf — mcp_config.json, where the address goes under serverUrl rather than url.
The first thing the server does with a new client is refuse it. That refusal carries the address of the sign-in service, and it is how the handshake begins — every client here handles it without being told. Seeing one in a log is not a failure.
For a starting point to discover project tools and machine-readable documentation, see API and developer resources.
Working with an agent
An assistant finds its way in the same order you would. list_workspaces gives it the workspaces you belong to, list_projects the projects in one of them, get_project the sheets in a project, and get_sheet everything on a sheet — components, cavities, cables and wires. After that it has the names it needs to change anything.
- “List my projects and tell me which ones have design rule violations.”
- “Add a 12-way connector to the engine sheet and wire cavity 1 through to the splice.”
- “Every wire between X1 and the splice should be black — fix the ones that are not.”
- “Produce the cut list for this project and tell me the three most expensive parts in the BOM.”
- “Trace the red wire out of X1 cavity 4 and tell me where it lands.”
- “What else is on the CAN-H network, and does any of it leave this sheet?”
- “Rename the network carrying CAN-H and make sure it is twisted with CAN-L.”
- “Tidy up the layout on sheet 2 and show me what it looks like.”
Names, not ids
Sheet-scoped tools address things by the names you already see: a component by its name from get_sheet, a library part by its part number. There is no internal identifier to hunt down and none to paste — which also means that renaming a component in the app changes how an assistant has to refer to it.
Leave alone or clear
Write tools follow one rule throughout. An argument the assistant leaves out is left alone; an argument it sets to null is cleared. That is the whole difference between not changing a label and removing one, and it is worth knowing when you read back what an assistant says it did.
Ask for run_drc after a batch of edits, and for screenshot_sheet once the batch is done. The checks are the same ones the app runs, so an assistant that clears them is clearing what you would have seen on the design rule checks card — and a screenshot is the only way it can tell whether the layout it produced actually looks right.
Limits and safety
| Limit | What it means |
|---|---|
| Deletes are canvas objects only | Components, cables, wires, labels, extra parts and shielded cables. A library part, a project or a sheet can never be deleted over MCP — those stay things a person does in the app. |
| Plan limits apply to creates | Refused exactly as they are in the app. Deletes are deliberately never plan-limited. See Pricing and plans. |
| 60 tool calls a minute | Counted per person, across every client you have connected. Over the limit, the call comes back as an error telling the assistant to wait and try again. |
| 6 screenshots a minute | screenshot_sheet has a budget of its own on top of the general one. A capture takes 10 to 40 seconds and returns a PNG whose longer side is between 512 and 4096 pixels, 1600 by default. |
| 100 design rule violations | run_drc returns at most 100, and declines a project of more than 600 components outright. |
| 100 search results | search_parts returns no more than that from the library at a time. |
| Imports are read-only | A project being built by Excel import is closed to writes until it finishes. |
screenshot_sheet is the one tool that goes further than the database: it signs a headless browser into your account, renders the canvas the way the app draws it, and signs that browser out again. The browser belongs to Cloudflare, listed on the subprocessors page.
Nothing an assistant does is a draft. Every change is written to the live project and synced to everyone working in it at once, the same as a change you make yourself.
Disconnecting
Wiring Studio keeps no list of connected clients. The connection lives in the client, so the client is where you end it.
claude mcp remove wiring-studio- Claude Code — the command above, which deletes the stored sign-in along with the server entry.
- Claude Desktop and claude.ai — remove the connector under Customize ▸ Connectors. On Team and Enterprise an owner removes it for the whole organisation.
- ChatGPT — remove the custom connector in settings.
- Everything else — delete the server's entry from the client's configuration file.
Removing the connection discards the sign-in the client was holding, and there is nothing left on the Wiring Studio side to clean up. An account with no client pointed at it is simply an account no assistant can reach.
Related chapters
Where this chapter leads next, and what it assumes you have already read.
Sheets and workspaces
Splitting a harness across sheets, mating connectors between them, and who owns the projects above that.
Excel import
Drop in a harness workbook and an agent builds the components, wiring, cables and pin assignments.
API and developer resources
Where agents discover project tools, read product documentation and find release notes.