eda-agent

MCP server that lets an AI (or any MCP-compatible client) interact with a live Altium Designer session, with KiCad and EasyEDA Pro available as additional backends. It exposes around 600 tools on Altium, covering schematic, PCB, library, project, and design-agent operations, over a persistent DelphiScript bridge. The AI reads the design you currently have open, asks questions about it, and can modify it in place while you watch. The backend is selected at startup, so each user sees only their own tool set.

⚠️ Experimental. Not all tools are extensively tested. Some can crash the Altium DelphiScript engine. See Known limitations before using on any design you haven't backed up.

Demo

Claude Code with eda-agent designs a round 54 mm, 4-layer RGB LED display board in Altium Designer from a written spec to manufacturing files. It builds a project library from scratch, with a symbol, footprint, 3D model and part numbers for every part. It then draws the schematic, places 61 LEDs in rings, routes the USB pair at 90 ohms, pours stitched ground, gets DRC clean and writes the Gerbers, drill, BOM, pick-and-place and STEP files. A correction round follows: a review prompt lists issues from the first pass, and Claude reroutes the whole USB pair as a coupled differential pair, gives every part a realistic 3D model from its datasheet drawing and finishes the schematics with title blocks. The result would still get a manual tweaking pass before prototyping, but it is already at a very good stage.

Claude Code with eda-agent draws a 12 V to 3.3 V, 2 A step-down supply around the TI TPS62130 in Altium Designer from one sentence. It fetches the datasheet, sizes the inductor, capacitors and feedback divider from it, builds the symbols, draws the schematic and verifies the netlist.

Support the project

Developing eda-agent and testing it against Altium's scripting engine takes a significant amount of work. If you find eda-agent useful in your work, a donation helps keep the progress going.

Dashboard

Two dashboards ship with eda-agent:

• In-Altium status window - a floating Altium-side window showing live status, request count, cumulative Altium-side time, auto-shutdown countdown, and a per-command log with durations. Hide pings filters the 30 s keep-alive traffic; Only >100ms isolates slow calls. The Detach button exits the polling loop cleanly; it saves nothing, so unsaved edits stay in the editor.
• Web dashboard - a local browser dashboard at http://127.0.0.1:8766, focused on design review. A Review tab surfaces datasheet / MPN / manufacturer / footprint coverage gauges and an actionable issue queue (missing datasheet, missing MPN, orphan nets, ...); Project, Components, Nets, Libraries and Plan tabs give live structured views. Click any component or net to drill into a detail drawer; one click cross-probes it into Altium. Light / dark theme, server-sent-events live feed. It is auto-started by the MCP server - the Open Dashboard button on the in-Altium status window launches the browser.

How it works

• Altium Designer stays open and in full control of your design
• A DelphiScript polling loop runs inside Altium's scripting engine
• eda-agent (Python, launched by your MCP client) sends commands via file-based IPC
• Altium executes, writes a response, and returns to polling
• You see the changes happen live in Altium

This is not a batch tool that opens a project, runs a script, and exits. It's a live connection for as long as you want it (conversational design review, guided refactoring, ad-hoc BOM queries, "what nets does this resistor connect to?"), all on the project you currently have open.

Features

• ~600 tools on the default Altium backend (600+ with both registered) across application, project, library, schematic/general, PCB, and design-agent categories
• Generic primitives (obj_query, obj_modify, obj_create, obj_delete, obj_run_process) that work on almost any schematic or PCB object type via late-binding, avoiding per-type handler proliferation
• Every tool takes a list: give nearly any tool items, a list of its own arguments, and the whole list is one call, one request to Altium and one undo step (pcb_place_arc(items=[...]) places twenty arcs that one Undo takes back). The reply gives each item's result in order. Some tools take their list directly: pcb_place_tracks, pcb_place_vias, pcb_move_components, sch_place_wires, sch_place_components, sch_set_components_parameters, lib_add_pins, proj_get_connectivity_many, sim_attach_primitives. Typical wall-time savings: 10 to 100x on multi-item edits
• Design review snapshot: design_review_snapshot bundles 8 to 12 review reads (project info, components, nets, rules, diff, messages, stats, unrouted, BOM) into a single call. One LLM turn instead of a dozen
• Design-lint sweep: design_lint_report runs 31 audit checks in one IPC pass and returns a structured violation list - schematic-side (component-parameter visibility per class, power-port orientation, floating ports, multi-output / no-driver nets, duplicate designators, off-grid components) and PCB-side (DNP variant components, tented-via ratio, near-miss track endpoints, signal vias without nearby return via, via antennas, removed pad shapes, components outside outline, pads too close to board edge, invalid polygon regions, optional DRC). Each check is also exposed as a standalone audit_* MCP tool; the dashboard's Status → Health subtab has a one-click Lint panel that calls /api/lint and groups results by Schematic / PCB
• Canonical circuit blocks: design_add_circuit_block folds a whole block into a DesignPlan in one call, allocating refdes, wiring every pin to the right net and tagging power / ground and roles. Twelve of them: decoupling, pullup, pulldown, series_resistor, voltage_divider, rc_lowpass, rc_highpass, led_indicator, crystal, pi_filter, mosfet_low_side, mosfet_high_side. Naming-agnostic: you supply the part identities, it owns only the wiring pattern. design_list_circuit_blocks returns each one's parameter contract, so the planner never guesses a parameter name
• Datasheet-first discipline: every component-surfacing response (pcb_get_components, proj_get_bom, proj_get_component_info_many, proj_find_component, lib_search, design_review_snapshot, sim_get_readiness) carries a _datasheet_guidance block with per-part vendor search queries. app_attach / app_ping carry a _system_reminder on their first call and every 10th after it (EDA_AGENT_REMINDER_EVERY sets the interval), so every MCP client that connects sees the rule at session start and again later. LLM-fabricated datasheet values are forbidden; WebFetch/WebSearch are called out by name
• Sch <-> PCB netlist crossref: obj_crossref_net(net_name) compares the schematic pin list against the PCB pad list for the same net. Catches ECO drift, stale post-fabrication routing, phantom nets from port/sheet-entry rename conflicts. in_sync flag + sch_only / pcb_only diff
• SPICE simulation workflow: sim_get_readiness audits every component and partitions into ready / needs-primitive / needs-file. sim_attach_primitives sets SpicePrefix + Value on passives. sim_attach_model links a vendor .mdl / .ckt. sim_run dispatches the simulator. Built-in guardrail: never fabricate a SPICE model file, fetch the vendor one
• Focus-independent PCB access: every PCB handler falls back to GetPCBBoardByPath when GetCurrentPCBBoard returns nil (user has a sch tab focused). No more misleading "No PCB document is active" when the PCB is right there
• Fast and compile-cached: persistent polling loop; ~10 ms per call in active mode. SmartCompile caches DM_Compile with a 2 s TTL so a multi-read review pays for one compile instead of a dozen. Explicit proj_force_recompile + proj_get_compile_freshness probes for cases that need a guaranteed-fresh netlist (e.g. after user edits)
• Editor and project settings, read back: board grids and the sheet's electrical grid, board and schematic editor preferences, auto-save, and project options (net identifier scope, output path, pin swapping). Every value written is read back, and one that did not take is reported in not_applied
• Rigid-flex and route clean-up: split a board into layer stack regions, give each region its own stack (a flex stack with fewer copper layers), add and edit bend lines with radius, angle and fold order, and run Altium's Gloss or Retrace on chosen nets with the track count and length reported before and after
• Layer stack manager: the whole physical stack with Z heights and finished thickness, dielectric and solder mask settings (Dk, Df, thickness, stiffener), layers inserted above or below a chosen layer, impedance profiles created and set per layer, and each via's protection structure and back drilling
• Board output and editor settings: the Gerber and print setup saved in a board, Testpoint Style rules, the coarse visible grid factor and each grid's unit, what pasting keeps and the paste array, confirmations, auto-pan and netlist-load behaviour, display fonts and colours, more schematic preferences, a pad's drill type, and sheet reference zones for every part, label and port
• **Net colour high