Agents & MCP New
How the Agent Understands a Project
On this page
- What it works from
- The design graph
- Parts, and the checks a part must pass
- Part contracts
- Datasheets WireFrame downloads itself
- Measurements, and pictures of what it drew
- Project memory, and who edited what
- The tools it may call, and the edits it may only propose
- What it does not see
- Your own agent, over MCP
- See also
WireFrame's AI Copilot — Penalty, in the chat — does not design from what a model remembers about parts, or from a guess at what your files say. It works from what WireFrame itself has read, measured and checked, and the model reasons over that. The model proposes; WireFrame's own code supplies the facts and checks the answer.
This page says what the agent works from, what it does not see, and how your own agent reaches the same engines over MCP. It links to the pages that cover each part in detail.
What it works from#
The design graph#
On a schematic, the agent answers from WireFrame's design graph — the parts, pins and nets read from your sheets, rebuilt whenever they change. On a board it reads the same graph plus the board itself. The findings in it come from WireFrame's own checks: /findings lists them with no model call, and /rebuild reads the graph again from the project files when an answer looks out of date. See Copilot commands.
Before there is a schematic, the agent holds a draft — the requirements, the BOM it chose and the netlist it is wiring — and reads it back with a tool (get_draft) rather than from its memory of the conversation. /bom, /nets and /missing show you the same draft. See Planning a design in the chat.
Parts, and the checks a part must pass#
Whether a part binds is decided by code, not by the model. The agent may propose a part; deterministic checks decide — the kind of part, its contact count, every symbol pin against a pad, the pads against the package drawing, copper that would short — and they give the same answer every time. Before it names a part in a BOM, the agent confirms the part is in the library on this machine (search_library, check_pool, inspect_library_symbol). See How a Part Is Found.
Part contracts#
What a part needs electrically — supply range, decoupling, pull-ups, strapping pins — is worked out from its datasheet and kept as the part's contract (/contract U1). A contract belongs to the part, not to the project, so every board that uses the part is held to it: by later reviews and /findings, and by Live Checks as you draw. When no contract covers a requirement, the agent's tool (get_contract) says it is unknown rather than guessing. See /contract.
Datasheets WireFrame downloads itself#
Pin functions and electrical limits come from a datasheet WireFrame has actually downloaded: the PDF you attach first, then the link in the library index, then the web — where the model may name a URL, but WireFrame downloads the file itself, keeps its hash and extracts the text. A link that does not download produces no claim, and a requirement with no downloaded page behind it is kept but capped, so it can never be reported as a fault. See Where the datasheet comes from.
The agent can also ask that downloaded document what it says on a topic (read_datasheet), and establish what is known about one exact part number before it drafts the part (research_part).
Measurements, and pictures of what it drew#
On the High-Speed Workbench's pages, every number the agent quotes comes from an engine run — see Fixes, Reports and the AI. A trace's or a via's current comes from ipc_calc, computed to IPC and never quoted from memory, and score_board gives the number the panel would show.
It also looks at what it made: a picture of the sheet as it is drawn (view_sheet) and a top-down picture of the board's placement (view_placement), each block in its own colour.
Project memory, and who edited what#
The agent keeps durable facts per project — requirements, constraints, decisions, corrections and preferences. They survive closing the chat, a new session and reopening the project: /memory lists them, /remember pins one and /forget drops one. A newer decision about the same subject replaces the older one, and the history is kept. Long sessions are summarized. See Project memory.
Some decisions are written down for it: an applied /fix repair, so later runs do not undo it; the layout rules a layout used, once you apply it, so the next conversation starts from them; and a finding you accept with a reason (accept 4 because …), which is no longer counted or sent to a fix.
Every edit on the undo stack carries who made it — you or the AI. After each edit, WireFrame carries your changes into the BOM plan and the netlist, and the repair and wiring agents are told what you changed and never to undo it. A change of yours that keeps the checks is your decision and is never reverted; one that breaks a check is pointed out and asked about. See Your edits flow back into the plan.
The tools it may call, and the edits it may only propose#
The agent works through tools. Which ones are offered follows what is open — the board tools need a board, the simulation tools a simulation — and on a real project with its schematic and board open there are 117. They are listed by task on Use WireFrame from your own agent: the same tools your own agent reaches over MCP.
Most of them read or measure. The ones that would change the design come in two kinds:
- Proposals, worked out on a copy and reported, changing nothing: a layout (
propose_layout,evaluate_layouts), a placement (propose_placement), a high-speed patch (propose_patch,preview_patch), a power fix (power_propose_fix,power_preview_fix), a part repair from/fix. - Steps that apply, each one undoable:
apply_layoutandapply_placementapply what was proposed;apply_approved_patchandpower_apply_approved_fixapply only what a person approved in WireFrame's own window. The model can propose; it cannot approve, set a result's status or produce evidence.
Some answers are never the agent's to give: the number of copper layers, splitting a product into several boards, and which of several measured options to keep. It asks, and records your answer. Every gate is listed on What waits for your approval.
What it does not see#
- Not the whole project with every question. A request carries your message and the part of the design it is about — a block, a net, the BOM rows in question, a datasheet page. Mention a reference designator (
U1) or a net name (VBUS) and only that part of the design is sent with it. See What is sent, and where. - Not your other projects. A project's own library is data of that project: the matcher refuses its files for another project, and a part reaches another project only after a person confirms it. Over MCP, an agent works on the active project; it can open another, but never sees two at once, and never closes one with unsaved changes.
- Not a datasheet WireFrame did not download. A paragraph the model says it read is never presented as evidence.
- Not what nobody stated. Load currents are yours to state — WireFrame does not guess a chip's consumption. A stack-up nobody confirmed caps every high-speed result at WARNING, and a missing input such as a rise time or a load step makes a result UNKNOWN, never PASS. See High-Speed Workbench and Power Analyzer.
- No copy in a cloud. Your projects stay on your computer. WireFrame AI records which task was run and what it cost — not the contents of your messages or your design.
Your own agent, over MCP#
An agent you run yourself — Claude, Codex, Cursor or another MCP client — reaches the same engines through wf-mcp-server, the bridge installed beside WireFrame. The bridge talks to the WireFrame you have open over a local socket in your own user folder; there is no network port. See Connect Claude, Codex, Cursor or another agent.
It can work in three ways:
- Write the design itself with its own tools —
submit_bom,bind_part,submit_netlist,submit_blocks,edit_schematic— and askdesign_statuswhether it is done. The reasoning is your agent's, and such a call spends no AI credits. - Hand a job to WireFrame's agent with
ask_penaltyorrun_command. WireFrame's agent then works from everything above — the design graph, the contracts, the datasheets, the project's memory — with its own sequencing, and spends your plan's AI credits exactly as it would if you had typed the request in the panel. - Call the design tools itself with
call_tool. The reasoning is your agent's, and WireFrame supplies the measurements, by the same code that answers the Copilot panel:score_boardover MCP gets the number the panel would show. Such a call spends no AI credits.
Either way the same rules hold. Nothing runs until you press Allow; proposals work on a copy; a high-speed patch or a power fix waits for your approval in WireFrame's own window; and each step that applies is one undoable step, recorded against the client that made it. Your agent works on the active project — it can open another or start a new one, and closes one only when its work is saved — it cannot export Gerbers, and only one client is connected to a WireFrame at a time.
What your agent does with an answer is between you and your agent's provider. For MCP itself, WireFrame sends your account only how many calls were used and the name of the agent that used them. See Your design stays on your machine and the MCP tool reference.