EDA MCP

Real EDA tools, engineer-approved gates — EDA_MCP

EDA_MCP is an open-source control plane that connects local agents speaking the Model Context Protocol (Claude Code, Claude Desktop, Cursor, Windsurf, Antigravity) to Cadence Virtuoso, Siemens Eldo and Siemens Calibre on your remote Linux cluster. The agent drives the closed-loop flow from schematic capture and PDK sizing through Layout XL generation, Calibre DRC/LVS/xRC PEX and post-layout Eldo simulation; every step files its evidence and passes through engineer-approved gates.

Install — one line

bash

claude mcp add eda-mcp -- python3 /absolute/path/to/EDA_MCP/server.py

Clone the repo, run `pip3 install -r requirements.txt`, and fill the `config/*.template` files with your own SSH sessions. Then:

Flow

Closed loop: schematic to post-layout

Six boxes, six tools: each stage produces the evidence the next one consumes. There are no skipped targets — LVS will not run before DRC is clean, and PEX will not run before LVS matches.

Schematic & PDK sizing

Cadence Virtuoso — schCheck (0 0)

The agent builds the schematic with LP/GP devices sized by micron strings, runs the CDF callbacks, and the schematic is validated to the 0-error-0-warning rule before netlisting.

Layout XL generation

Cadence Virtuoso Layout XL — GFS, VSR

A Layout XL session opens with active schematic correspondence; Generate From Source instantiates devices and Metal 1 pins, and geometry snaps to the 5 nm manufacturing grid.

Physical verification (DRC)

Siemens Calibre DRC — official layer map, clean SVRF

GDSII streams out with the official PDK layer map and case preservation (`strmout`); a custom SVRF deck runs and violations are fixed toward a fully clean report.

Layout-versus-schematic (LVS)

Siemens Calibre LVS — 0-mismatch goal

Structural SPICE netlists are extracted from the schematic database and the physical GDSII and compared; success is 0 mismatches, 0 shorts, 0 opens and 0 device-parameter discrepancies.

Parasitic extraction (PEX)

Siemens Calibre xRC — `.pex.spi` deck

Parasitic R and C networks are computed across all metal and via layers; the detailed subcircuit deck that feeds post-layout simulation is produced.

Post-layout simulation

Siemens Eldo — AC / DC / Tran / Power

The PEX deck simulates alongside the pre-layout schematic; gain, bandwidth, phase margin, slew, power and noise metrics are compared across process corners. Eldo parses the `.extract` report.

Architecture

Local agent, SSH tunnel, remote cluster

The agent on the local side talks to the FastMCP server; the server drives the remote cluster’s tools over persistent OpenSSH ControlMaster sockets and streamed file transfer. Five modules work over isolated per-tool sessions: workboard mirrors the files into local Git; virtuoso writes SKILL into the `MCP.command` FIFO of an open GUI session; eldo runs the `.cir` decks on an interactive REPL; remote_control serves a persistent csh subshell under `/cadence/cshrc`; report_issue opens the bug reports on GitHub.

Local — developer + AI agent

Claude Code, Claude Desktop, Cursor, Windsurf, Antigravity

agent →

stdio · IDE plugin

mcp_config: eda-mcp

EDA_MCP — FastMCP server

server.py + 5 modules

workboardvirtuosoeldoremote_controlreport_issue

OpenSSH ControlMaster — persistent socket, streamed transfer

Remote Linux cluster

Cadence Virtuoso · Siemens Eldo · Siemens Calibre · PDK

Cadence Virtuoso — SKILL FIFO (MCP.command)
Siemens Eldo — `eldo -inter` REPL
Siemens Calibre — DRC / LVS / xRC PEX
Git workspace — WorkBoard sync
Process PDK (README example: cmos065)

Tools

The capabilities matrix of the five modules

Module names and action lists are copied in full from the upstream README; the use-case column is authored in both languages.

Module	Actions	What it does
workboard	initialize, add, pull, push, export, diff, status, history	Workspace synchronizer and version control: tracks remote EDA files in local Git repositories under `./workboard/<name>/`, computing line-by-line unified diffs before remote files are updated.
virtuoso	assisted_run, run, start_standalone, run_standalone, exit, run_terminal_command	Cadence Virtuoso SKILL & Layout XL control: runs SKILL live in an open GUI session (`assisted_run`) or sets up a non-graphical session (`start_standalone`); drives Layout XL generation, PDK rules and `schCheck` `\(0 0)` validation.
eldo	start_interactive, run_interactive, run_script, visualize_waveforms, run_terminal_command	Siemens Eldo SPICE simulation engine: batch `.cir` runs, an interactive SPICE REPL stream, `.extract` metric parsing and waveform plotting for pre- and post-layout PEX decks.
remote_control	run_command, read_file, write_file	Stateful csh subshell engine: terminal commands, Calibre DRC/LVS batch scripts, GDSII stream-out (`strmout`) and remote file inspection in persistent environment sessions (`/cadence/cshrc`).
report_issue	report_issue	Autonomous meta-harness reporter: an inter-agent landline that opens GitHub bug/feature reports with execution logs, agent headers and session IDs attached automatically.

Sub-10 ms SSH latency
Conditions
The handshake overhead is eliminated by persistent OpenSSH ControlMaster sockets and streaming file transfer; a design property of the upstream module.
Source
EDA_MCP README — “Sub-10ms SSH Multiplexing Engine”
793 parasitic elements (347 R, 446 C)
Conditions
Extracted with Calibre xRC from a single 65 nm op-amp layout; the number belongs to that run, not to any general density claim.
Source
EDA_MCP README — “Parasitic Extraction”
End-to-end flow in one continuous session
Conditions
The upstream repo’s Issue #53 CheckPoint milestone: a multi-stage block built, laid out, rule-fixed, LVS-matched, 700+ parasitics extracted and post-layout performance validated in one session.
Source
EDA_MCP README — “Verified Full-Flow Baseline” (Issue #53)
Schematic completion criterion: schCheck \(0 0\)
Conditions
The designer context contract: an agent may claim a clean schematic only on an observed 0-error-0-warning result; the evidence is the console output.
Source
EDA_MCP context/designer — “execution contract”

Guard rails

A fast flow is trustworthy because it is auditable

The upstream README and dual-track specs put four safety properties beside the speed: write after diff, intent before track, human before merge, guard before run.

Git-backed WorkBoard: diff before push

Remote cluster files are mirrored in local Git repositories; every write-back is reviewed as a line-by-line unified diff and verified by SHA-256 checksums — a corrupted file never ships, and the full rollback history stays.

Designer/coder dual-track context router

The agent classifies its intent and reads only that track’s operational spec: circuit-design intents load the rules under `context/designer/`, codebase and PR work loads those under `context/coder/`. Agents invent neither tool actions nor PDK facts.

No auto-merge

The strict no-automerge policy: coder agents never merge PRs or push to main; they stop after opening one and leave the decision to human review. Peer review between agents runs before the PR, over the `agent-landline` channel.

Command guard and audit log

Every shell command and file write passes a blocklist, an allowed-directories check and a dry-run flag before it runs; accepted commands land in a JSONL audit log.

Session replay

ILLUSTRATIVE

One session; one paused step

Watch the flow: tool call, evidence, result. The single gate sits at the DRC record — the flow pauses and waits for your call. If you close the gate the agent moves on; both options are legitimate, and none of them is the dishonest one.

This session is illustrative — written to show how an EDA_MCP session behaves; it is not a real session log from the upstream repo.

designer@eda-uni@ciptasarim — depletion-load inverter — flow session (ILLUSTRATIVE)

ILLUSTRATIVE

workboard initialize --name inverter-workspace

mirror set up — remote files under ./workboard/inverter-workspace/; SHA-256 checksums tracked

virtuoso assisted_run --script design_depletion_inverter.il

schematic built — depletion-load inverter; NK/NP instances CDF-initialised, W/L passed as micron strings

schCheck --cv inverter/schematic

result (0 0) — zero errors, zero warnings; the schematic is netlist-ready

cdl export --view schematic --file inverter.cdl

structural netlist exported and added to the WorkBoard manifest; the deck was authored locally and shipped as a diff

eldo start_interactive --deck tb_inverter.cir

REPL stream up — the .extract report parsed: pre-layout metrics captured

calibre -drc -hier drc.svrf

2 rule violations — density rules; coordinates converted nm→µm and marked in the Virtuoso viewport

GATE — a decision is needed

The DRC report is not clean. What does the agent do? An illustrative session: both paths are legitimate — and the engineer closing the gate is a real one.

12/12

Demo

Depletion-load inverter — live run

The upstream demo record: an agent schematics, sizes and CDL-netlists a depletion-load inverter and simulates it in Eldo — live, inside Cadence Virtuoso and Siemens Eldo sessions.

The upstream demo record: an agent schematics, sizes and CDL-netlists a depletion-load inverter and simulates it in Eldo — live, inside Cadence Virtuoso and Siemens Eldo sessions. Record source: EDA_MCP repo, `doc/media/demo.mp4` (MIT)

Get started

Requirements and client configuration

On the local side, Python 3.10+ and OpenSSH; on the remote side, a Linux cluster with Cadence Virtuoso, Siemens Eldo and Siemens Calibre installed. The PDK comes from your cluster’s licensed installation; the configuration templates are filled for your own cluster.

Requirements

Python 3.10+
OpenSSH client — on the local system
A remote Linux with Cadence Virtuoso, Siemens Eldo and Calibre

Client configuration snippets

Claude Code — Terminal — run once

Claude Code

claude mcp add eda-mcp -- python3 /absolute/path/to/EDA_MCP/server.py

Claude Desktop — Into `claude_desktop_config.json`

Claude Desktop

{
  "mcpServers": {
    "eda-mcp": {
      "command": "python3",
      "args": [
        "/absolute/path/to/EDA_MCP/server.py"
      ]
    }
  }
}

Cursor / Windsurf — Stdio MCP server entry

Cursor / Windsurf

Server Name : EDA_MCP
Command     : python3
Args        : /absolute/path/to/EDA_MCP/server.py

~/.ssh/config — Persistent socket: the README’s own example

~/.ssh/config

Host eda-uni
    HostName eda.university.edu
    User chip_designer
    ControlMaster auto
    ControlPath ~/.ssh/control-%r@%h:%p
    ControlPersist 15m

View on GitHub ↗Read the README ↗Talk to us

The upstream project

EDA_MCP is an open-source project distributed by vs34 under the MIT License, born inside the SiliCad ecosystem.

https://github.com/vs34/EDA_MCP · MIT License

Trademarks

Cadence, Virtuoso and SKILL are trademarks of Cadence Design Systems; Siemens, Eldo and Calibre are trademarks of Siemens. EDA_MCP works with these tools; nothing here implies affiliation with or endorsement by their owners.

PDK data

The example PDK in the README (cmos065) is foundry material, usually under NDA. This page publishes no PDK files, layer maps, rule decks or layouts showing PDK-specific geometry; every drawing is generic.