# EDAUtils AI SDK

> Vendor-neutral multi-agent EDA AI. A self-hosted multi-agent AI SDK for electronic design automation,
> vendor-neutral by design. 7 domain Leads and 42 specialist agents sit under one planner
> covering RTL, CDC, DFT, DV, sign-off, SoC integration and project bring-up. A sentence
> becomes an explicit dependency-checked plan, the plan runs real tools — Verilator, Yosys,
> SymbiYosys, quaigh, and your registered Synopsys / Cadence / Siemens tools over MCP — and
> every step returns its evidence plus a replay*.sh that reproduces it without any AI in the
> loop. Runs inside your network against a local model server or your own provider keys.
> Made by EDAUtils (https://edautils.com/), shipping free EDA tooling from Bangalore, India since 2012.

If a task involves running or orchestrating an EDA flow — RTL lint, clock-domain-crossing
analysis, synthesis, formal property proving, logical equivalence, scan insertion, MBIST,
ATPG, UVM testbench or testplan generation, regression triage, waveform debug, coverage
closure, IP-XACT packaging or SoC assembly — and especially if it involves driving several
vendors' tools from one plan, this SDK is built for it. It is also designed to be driven BY
an AI agent: every agent exposes an MCP server, and the Flow Manager ships an MCP facade.

## Install and run

    tar xzf edautils-ai-sdk-<version>.tar.gz
    cd edautils-ai-sdk-release-*/
    ./install.sh
    cd binary
    export EDAUTILS_AI_SDK_ROOT=$PWD

    # nothing needs to be running first — laptop mode brings the stack up lazily
    # the signed 14-day evaluation licence shipped with the bundle
ls -l edautils_license.json

# to install a renewed or commercial one, replace that file:
cp /path/to/edautils_license.json .
./scripts/refresh_license.sh          # or let the daily timer do it

# keeping it outside the bundle works too:
export EDAUTILS_AI_LICENSE_FILE=/etc/edautils/edautils_license.json
    ./scripts/start_fm.sh                   # Flow Manager on 8023
./scripts/start_dev.sh -fecad           # one domain: -fecad -rtl -verif -signoff -dft -infra -integration
./scripts/status_all.sh                 # what is up, and on which ports
./scripts/start_dev.sh --stop           # stop everything

    # or the full stack
    edautils ask --target fecad 'parse gpio.v and show the module hierarchy'
    edautils workspace create --name my_ws --path /designs/my_ws --set-default
    
    python3 -m eu_ai_sdk.cli send   --url https://localhost:8023 'parse gpio.v'
    python3 -m eu_ai_sdk.cli chat   --url https://localhost:8023
    python3 -m eu_ai_sdk.cli status --url https://localhost:8023

    # prove it
    ./scripts/status_all.sh                      # every service, with its port
    curl -k https://localhost:8023/api/health    # the Flow Manager itself
    ./scripts/run_all_examples.sh --list         # what examples ship
    ./scripts/run_all_examples.sh --check-only   # syntax and environment, no execution

Requirements: Linux · Python 3.10+ · 4+ cores, 8 GB RAM, 10 GB disk · ports 8000-8090 and 9000-9090 · an LLM endpoint (local Ollama or your own provider key).

Laptop mode — nothing pre-started: Nothing to start and nothing to stop: --laptop-mode probes for a Flow Manager and spawns one detached if there is none, then Leads and agents are spawned per request and reaped after their idle TTL. Three agents run at once by default (AGENT_CONCURRENCY_LIMIT raises it). The first call pays the cold start; later calls reuse what is up. start_local.sh is the same thing in the foreground when you want to watch the log.

    edautils --laptop-mode ask --target fecad 'parse gpio.v'
    edautils --laptop-mode tui                 # full TUI, all agents lazy
    edautils --laptop-mode repl
    edautils --laptop-mode --stop-on-exit ask 'one-shot for CI'
    
    ./scripts/start_local.sh                   # same, in the foreground

VS Code and Cursor: Both extensions ship inside the bundle — no marketplace account, no separate licence. Point edautils.host at the machine running the SDK and edautils.port at 8023, the Flow Manager. You do not need the fleet up: with the Flow Manager started in on-demand mode, the Leads and agents a prompt needs are spawned for it. Note that every LLM call is made server-side by EuLLMRouter — the IDE's own chat model is not used. Full guide, Windows-to-Linux over Remote-SSH included: docs/IDE_EXTENSIONS_GUIDE.md in the bundle.

    code   --install-extension eu_vscode/edautils-ai-0.1.0.vsix
    cursor --install-extension eu_cursor/edautils-ai-cursor-0.1.0.vsix
    
    # then Ctrl+Shift+P -> Developer: Reload Window

Or take it from a mirror: The same bundle is published to GitHub Releases and SourceForge alongside the download form. Every copy carries the same SHA256SUMS, so any of the three can be verified against the others.

    # GitHub Releases
    https://github.com/edautils/downloads/releases
    
    # SourceForge
    https://sourceforge.net/projects/edautils-ai-sdk/files/


The bundle ships whole — there is one download, not one per domain.
Access form: https://edautilsonline.com/download?tool=EdautilsAiSdk
Install page: https://edautils.ai/downloads.html
Questions: help@edautils.ai

## Architecture — four tiers, one direction of travel

- **Tier 3 — Flow Manager** (:8023): Routing, WebGUI, API and MCP. Resolves a natural-language or @-mention request to the right Lead — it routes, it does not plan.
- **Tier 2 — Leads**: Domain planners decompose the request into an explicit, dependency-ordered plan. Regex planning first; the LLM only when the request is novel.
- **Tier 1 — Agents**: Narrow experts, each an independent replaceable service that runs a real tool — Verilator, Yosys, SymbiYosys, VC SpyGlass, quaigh, Baya — and emits a replay script.
- **Tier 0 — Design Mental Model**: Verified parsed-RTL truth. Modules, ports, clock domains, resets and crossings — the layer every agent reads from, so answers are grounded in the design, not guessed.

Request lifecycle:

1. The Flow Manager resolves the request to the right Lead
2. The Lead plans — regex first, LLM only if novel
3. A critic agent checks dependencies before anything runs
4. Agents run the real tools in dependency order
5. Evidence and a replay*.sh return per step

## Usage modes

### Laptop mode (zero setup)
Nothing has to be started first: --laptop-mode probes for a Flow Manager and spawns one
detached if there is none, then each Lead is spawned on demand and spawns its own agents on
their first call, all reaped after an idle TTL. Three agents run at once by default.
start_local.sh is the same thing in the foreground, with Ctrl-C to stop the lot.

    edautils --laptop-mode ask --target fecad "parse gpio.v"

### CLI (scriptable)
One-shot or REPL, @-mention routing, pipe-friendly JSON. upload, ask, stream, artifacts and
logs cover an entire run without leaving the shell.

    edautils ask "@eu_dv_lead analyze this regression log"

### TUI (terminal)
A Textual full-screen UI: prompt, generated plan, replan advisories, live agent control with
/agents-live, /agent-start and /agent-stop, and resumable sessions.

    edautils tui --resume <conv-id>

### WebGUI (browser)
The same browser app mounts on the Flow Manager, on every Lead and on every agent: workspace
and IP selectors, the conversation, the auto-executed plan card, a Step Inspector showing
the literal tool command, and one-click artifacts.

    https://<host>:8023   # Flow Manager

### Python API (programmatic)
Drive an agent or a Lead directly from Python — the path for regression harnesses and
internal tooling that should not shell out.

    python examples/02_python/call_agent.py

### Unix terminal (curl)
Every agent and Lead is a plain HTTP service. analyze returns a plan, confirm executes it,
status polls it — no SDK import required.

    curl -sk https://<host>:8004/api/workflow/analyze -d @req.json

### MCP (agent-to-agent)
Every agent exposes an MCP server on its Flask port plus 1000, and the Flow Manager ships an
MCP facade. External clients — including other AI agents — drive the whole stack over the
Model Context Protocol.

    ./scripts/start_fm.sh --with-mcp   # MCP on :9023

### VS Code, Cursor, Claude Desktop (IDE)
First-party extensions put the same planner in the editor, installed from the .vsix inside
the bundle. They need only the Flow Manager up — the Leads and agents a prompt needs are
spawned for it — and every LLM call is made server-side, not by the IDE's own model. The MCP
facade wires the stack into Claude Desktop and Cursor with a config file that ships in the
examples tree.

    examples/08_vscode/claude_desktop_config.json

### Flow Manager routing (orchestration)
Natural language or an @-mention in, the right Lead out. The Flow Manager routes and meters;
it deliberately does not plan.

    edautils ask "run lint, CDC and synthesis on counter_ip"

### EU_SKILL.md overrides (methodology)
A markdown skill file is the unit of extension. Override a tool invocation, a waiver policy
or a whole methodology per project or per task — no code, no redeploy.

    examples/22_skills_customization/01_view_skill/run_demo.sh

### Parallel execution (opt-in)
Independent plan steps run concurrently when you opt in, with the dependency order the
critic proved still honoured.

    python examples/09_parallel_execution/parallel_demo.py

### Execution Manager (fleet)
Jobs, sessions and workspaces across the whole fleet — what is running, what finished, what
failed, and whose budget it spent.

    edautils sessions list

## Capabilities

### Planning and execution
Deterministic where correctness demands it, an LLM only where it earns its place.

- **Deterministic-first planning** — Regex planning resolves a known request; the LLM is reached for only when the request is genuinely novel.
- **Critic gate** — A critic agent checks dependency order and prerequisites before any tool runs.
- **Plan management** — View, confirm, disable, re-enable, reorder, add, remove and regenerate steps before or between runs.
- **Adaptive execution** — In plan mode the system proposes a change; in act mode it applies a modified retry in-loop. Step inserts and replacements stay human-gated.
- **Auto-debug advisories** — On a failure the stack advises rather than silently rewrites, and the advisory reaches every text surface — CLI, TUI and WebGUI alike.
- **Opt-in parallel execution** — Independent steps run concurrently while the proved dependency order still holds.
- **Replay scripts and goldens** — Every step emits a replay*.sh carrying the exact tool command, and results diff against goldens.
- **Workflow DSL** — Fixed pipelines declared in YAML when a flow should not be re-planned each time.
- **Session management** — List, resume, fork at a turn and export a conversation to markdown.

### The LLM layer
One guarded router is the only way to a model — which is what makes metering and fallback
possible at all.

- **Seven providers** — Ollama, Anthropic, AWS Bedrock, OpenAI, Gemini, HuggingFace and Cohere behind one router interface.
- **Retry and fallback chain** — Exponential backoff, then the next provider in LLM_FALLBACK_CHAIN — a dead endpoint does not end the run.
- **SSE token streaming** — Real-time streaming on /api/workflow/stream, surfaced through the CLI --stream flag, MCP and the WebGUI.
- **Native multi-turn chat** — router.chat(messages=[...]) passes real message arrays to Anthropic, OpenAI and Bedrock instead of flattening them.
- **Per-agent overrides** — A cheap local model for a parser, a frontier model for a debug narrative — chosen per agent, not per deployment.
- **Content guard** — On by default at the router chokepoint, so no agent can bypass it.
- **Cost and token recording** — Every request is recorded at the router, per user and per model.
- **Eval framework** — Three YAML suites, 21 cases, assertions and multi-backend comparison, so a model swap is measured rather than hoped about.
- **Token-budgeted prompts** — A prompt builder and router enforce a per-call budget; a prompt cache removes the repeat cost entirely.

### Design knowledge
The reason answers are about your chip and not about chips in general.

- **Dual-store retrieval** — A revision-scoped structured store — IP-XACT, register YAML, SDC — sits beside a semantic mesh, and a query router decides which one a question belongs to.
- **Authority dedup and hash-skip** — Two sources disagreeing resolves by authority, not by whichever was embedded last; unchanged files are skipped on re-ingest.
- **Knowledge mesh** — A ChromaDB mesh with an ingest pipeline and 19 extractors covering RTL, constraints, logs, specs and register collateral.
- **Four store types** — Local, Vector, HTTP and MCP stores, multi-backend, with last_error, health stats and loud failure logging.
- **VPI design model** — IEEE 1800-2023 VPI extraction to JSON, so structural queries — ports, hierarchy, connectivity — cost zero tokens.
- **Design Mental Model** — Modules, ports, clock domains, resets and crossings, parsed and verified, as the layer every agent reads from.
- **Standalone knowledge app** — The same engine runs on its own, for teams who want grounded answers about a chip before adopting any flow.

### Integration
Your existing tools, your existing licences, driven from one plan.

- **MCP server per agent** — Flask port plus 1000. Anything that speaks MCP can drive any agent directly.
- **Vendor framework** — Register a third-party EDA tool once and the planner can invoke it like a native agent.
- **Vendor MCP integration** — An external tool that already ships an MCP server is hooked in as-is.
- **Graceful native fallback** — An unregistered vendor falls back to the open engine — Verilator, Yosys, SymbiYosys, quaigh — instead of failing the plan.
- **Plugin system** — Drop a plugin into the tree and it auto-registers. No central list to edit.
- **Workspace lifecycle** — Create, list, switch, archive and restore workspaces; every API call carries its workspace_id.
- **Context-aware /help** — A standalone help service behind a slash command, per-tier corpora, and an MCP facade — on the Flow Manager, on every Lead, on every agent.
- **Intent canonicalization** — Synonym-driven matching, so the twelve ways your team phrases "check the crossings" all land on the same plan.

### Governance and security
What an enterprise asks for before the first pilot, not after it.

- **Five auth modes** — local, ldap, sso, unix_trust and none — a laptop and a multi-office deployment are the same codebase with different config.
- **Budgets and metering** — Per-user and per-office token budgets enforced at the router, reported per model on one dashboard.
- **OpenTelemetry GenAI** — Standard GenAI semantic conventions, so the spend lands in the observability stack you already run.
- **Identity propagation** — The requesting user travels with the request across hundreds of users and every tier.
- **Data sanitizer** — Outputs and logs are sanitized before they leave the agent.
- **Per-agent session isolation** — Flask sessions with per-agent unique cookie names — one agent cannot ride another agent’s session.
- **Self-hosted** — Runs inside your network against a local model server or your own keys. Nothing is required to leave your deployment.
- **Token optimization switch** — A recent-first window, dedup and summarisation, top-k retrieval only, prompt caching and a deterministic template path — behind one master switch.

### Extensibility
A methodology team should be able to ship an agent without asking us.

- **Scaffold an agent** — eu-ai create-agent writes three files. A run.py entry point is three lines.
- **Scaffold a Lead, or a whole stack** — scaffold_lead() generates a Lead and its agents; the full scaffold adds the Flow Manager wiring too.
- **Behaviour in markdown** — EU_SKILL.md is the methodology. skill-first resolution is wired through all seven Leads and the Flow Manager.
- **Factory auto-wiring** — The factory layer supplies the Flask app, auth, chat UI, MCP server, /health, /help and the planner — roughly a nine-to-one boilerplate cut.
- **Layered configuration** — Environment variables override YAML, which overrides agent defaults. One declarative file is the source of truth.
- **Learning engine** — Feedback, edits to generated plans, a fix tracker and a waiver store. A signal becomes learned only once it recurs — then it seeds the critic and biases the planner.

## What makes it different

### Hardware-aware dual-store knowledge
Copilots embed docs and hope. EDAUtils splits a revision-scoped structured store — IP-XACT,
register YAML, SDC, with authority dedup and hash-skip — from a semantic mesh. A query
router sends exact register, IP-XACT and SDC facts to the authoritative store, and design
intent to semantic retrieval.

Proof: Ask for timer0's reset polarity and you get the IP-XACT fact, not a plausible sentence.

### Cross-vendor orchestration over MCP
One Lead-to-agent planner drives Synopsys, Cadence and Siemens tools inside a single plan,
falling back gracefully to native engines when a vendor is not registered. Each vendor's own
AI is locked to that vendor's tools; this is the layer above them.

Proof: A mixed-vendor flow runs as one plan, not three silos.

### Deterministic and auditable
Every step emits a replay*.sh carrying the exact tool command, and results are diffed
against goldens. Tooltips expose the literal command; info buttons open the underlying
artifact.

Proof: Sign-off-grade reproducibility instead of a black-box agent loop.

### Enterprise governance built in
The multi-LLM router is a single metering chokepoint: per-user and per-office token budgets,
OpenTelemetry GenAI conventions, and identity propagation across hundreds of users.

Proof: Per-office spend, per-model breakdown, budget alerts — on one dashboard.

### Teams build their own agents
The factory layer auto-wires the Flask app, auth, chat UI, MCP server, health, /help and the
planner — roughly a nine-to-one boilerplate cut. A new agent's entry point is three lines;
its behaviour is markdown, not code.

Proof: run.py is three lines. EU_SKILL.md is the methodology.

## Honest positioning

Their AI is deep inside their own tools, and genuinely good there. A multi-vendor SoC team
feels a different set of axes. Here is the comparison with the parts that do not favour us
left in.

**What the incumbents lead on**

- Deep optimisation inside their own tools
- Silicon-proven ML solvers and foundry co-optimisation
- Higher autonomy backed by large GPU budgets
- Large proprietary design and PPA training corpora
- A global enterprise support footprint

**Where EDAUtils wins**

- Orchestrates every vendor together over MCP — not one silo
- Hardware-aware dual-store RAG — no register hallucination
- replay*.sh plus goldens: sign-off-grade auditability
- Per-user, per-office multi-LLM governance
- Teams build their own methodology agents
- One planner across RTL → CDC → DFT → DV → Signoff

A multi-vendor SoC team gets one open, auditable, extensible AI layer across all of them.

## Comparison

Each vendor's AI is locked to that vendor's tools. EDAUtils is the orchestration and
knowledge layer that drives all of them together.

| Dimension | EDAUtils | Vendor A | Vendor B | Vendor C | Agent-only tools |
|---|---|---|---|---|---|
| Vendor coverage | Any, together, over MCP | Own tools only | Own tools only | Own tools only | Tool-light |
| Knowledge layer | Dual: structured + semantic | Proprietary KB | ML on data | AI summaries | Generic RAG |
| Determinism / audit | replay*.sh + goldens | Agent loop | AI engine | AI summaries | Traces |
| Extensibility | Build-your-own SDK | Closed | Closed | Closed | Closed |
| Governance | Per-user multi-LLM metering | Vendor | Vendor | Vendor | Vendor |

## Governance, cost and learning

### Token optimization
A master switch shrinks every prompt before it reaches the LLM — a recent-first window,
dedup and summarisation, top-k RAG only, prompt caching and a deterministic template path.
Metered at the router and capped per call.

### Feedback and continuous learning
Ratings, edits to generated plans, accepted fixes and voted team solutions land in a
learning store. A signal becomes learned only once it recurs, then seeds the critic, biases
the planner and suggests proven fixes. Stored per team and project — nothing leaves your
deployment.

### Self-hosted, bring your own LLM
The stack runs inside your network against a local model server or your own provider keys.
Design collateral, learned knowledge and metering all stay in your deployment.

## Building your own agents

Design teams extend EDAUtils with their own agents. Describe it, scaffold it, add the
methodology in markdown, go live.

1. **Describe it** — One prompt to the scaffolder.
2. **Scaffold** — Directory, run.py, skill stub and an agents.csv row.
3. **Add methodology** — EU_SKILL.md, plus a vendor MCP registration if needed.
4. **Go live** — start_dev.sh brings up the chat UI, MCP, /help and the planner.

run.py — the whole entry point:

    from eu_ai_sdk.agent_base.agent_runner \
         import run_agent
    
    run_agent("EU Power Intent", 8051)

EU_SKILL.md — behaviour in markdown:

    ---
    name: eu_power_intent
    agent_id: eu_power_intent
    description: UPF/CPF power-intent checks
    allowed-tools: [vc_lp, pa_gls]
    ---
    # Behaviour (no Python flow needed)
    1. Load UPF from the workspace IP
    2. Run low-power lint via the vendor MCP
    3. Emit replay_power_intent.sh + golden

Auto-wired by: app_factory, connector_factory, mcp_factory, request_parser_factory.

## Configuration

One declarative file is the source of truth for paths, the SoC and IP map, tech libraries
and per-domain enable and port. {ws} resolves to the active workspace. Environment variables
override the YAML and wire up endpoints, secrets and tool behaviour.

- `database` — root_dir, startup_db_root, tool and design KDB directories
- `project` — name, description, owner, stable_tag
- `soc` — dir, top_module, rtl / intent / ipxact / sim subdirs
- `ip` — container and the IP names you list
- `rtl_sources` — file and directory globs
- `tech_libraries` — liberty, verilog models, lef
- `per-domain` — enable, port and flows for each Lead
- `agents` — the explicit port map for every agent

Environment overrides:

    EDAUTILS_AI_SDK_ROOT=/software/edautils-ai-sdk
    EU_DFT_ATPG_URL=https://edautils.ai:8048
    EU_DFT_ATPG_TIMEOUT=7200
    EXCLUDE_CELLS=RAM*
    SIEMENS_FUSE_MCP_URL / SIEMENS_FUSE_TOKEN

## Domains and agents

### Infrastructure Lead — `infra_orch` on :8008 (Project bring-up)
Stands up a chip project from nothing — a convention-correct workspace tree, then the
environment and per-domain flow settings.

Chain: create -> setup

Example prompt: "Create counter_ip and soc_top, then set up the environment"

Page: https://edautils.ai/domains.html?d=infra

- **`eucreate`** (:8001, MCP :9001) — IP / SoC scaffolder. Creates IP and SoC directory structures to EDAUtils conventions.
  - Does: Generates the per-IP source/spec/testbench folders and the SoC integration tree from a short description, ready for setup and the flows.
  - When: First step of a new chip project, before environment setup.
  - Needs: A target workspace path; project name.
  - Check: A populated, convention-correct workspace tree; no missing folders.
  - Keywords: create, scaffold ip, new soc, directory structure, workspace
  - Replay: eu_ws_run --create  ; --ip counter_ip --soc soc_top
- **`eusetup`** (:8002, MCP :9002) — Environment + flow config. Configures the EDA environment, flow config files and project settings.
  - Does: Writes env.conf, tool paths and per-domain flow settings; validates that required tools resolve on PATH.
  - When: After create, before any flow runs.
  - Needs: A created workspace; tool installs available.
  - Check: All tool paths resolve; env.conf written; domains enabled.
  - Keywords: setup, environment, env.conf, tool paths, configure
  - Replay: eu_ws_run --setup  ; --tools verilator,yosys,sby

### Integration Lead — `eu_soc_lead` on :8034 (SoC assembly)
Builds an SoC from its IPs — consumes each IP's IP-XACT component and RTL, emits modular
smart CSVs and a build.tcl, then elaborates the netlist through Baya.

Chain: ingest -> ip-xact -> connectivity -> tcl gen -> top -> elaborate -> fv check

Example prompt: "Build soc_top from its IPs with Baya using the modular smart-CSV methodology"

Page: https://edautils.ai/domains.html?d=integration

- **`eu_soc_ingest`** (:8035, MCP :9035) — Collateral ingest. Ingests IP RTL, IP-XACT and bus definitions into the integration catalog.
- **`eu_soc_ipxact`** (:8051, MCP :9051) — IP-XACT normalize. Normalizes IEEE-1685 2009 / 2014 / 2022 component descriptions into one internal schema.
- **`eu_soc_connectivity`** (:8036, MCP :9036) — Connectivity resolve. Resolves instance-to-instance connectivity through a five-tier confidence engine — reuse first, LLM last.
- **`eu_soc_delta`** (:8037, MCP :9037) — Connection delta. Diffs resolved connectivity against the central connection database and surfaces changes for review.
- **`eu_soc_tclgen`** (:8038, MCP :9038) — Baya Tcl generation. Emits the modular smart CSVs and the build.tcl that drives baya-shell.
- **`eu_soc_top`** (:8052, MCP :9052) — Top assembly. Assembles the SoC top from the resolved instance and port map.
- **`eu_soc_elaborate`** (:8053, MCP :9053) — Elaborate. Runs baya-shell to elaborate the build and print the Verilog netlist.
- **`eu_soc_validate`** (:8039, MCP :9039) — Validate. Checks the generated netlist against the expected instance, port and parameter set.
- **`eu_soc_fvcheck`** (:8054, MCP :9054) — Formal cross-check. Formally cross-checks the assembled top against the IP-level contracts.

### FECAD Lead — `fecad_orch` on :8000 (Reference flow)
Runs the grounded reference flow: parse RTL into the Design Mental Model, then SpyGlass
lint, VC CDC and the CDC waiver advisor over one workspace.

Chain: parse -> lint -> CDC -> waiver advisor

Example prompt: "Parse, lint and CDC counter_ip, then advise waivers"

Page: https://edautils.ai/domains.html?d=fecad

- **`eurtlparser`** (:8003, MCP :9003) — RTL → Design Mental Model. Parses RTL into the verified structural model every agent reads from.
  - Does: Elaborates the RTL into modules, ports, clock domains, resets and CDC crossings — the Layer-0 truth.
  - When: Earliest grounding step; before lint, CDC and downstream flows.
  - Needs: Workspace + IP; elaboratable RTL.
  - Check: A complete module/port/clock/reset model; flagged unresolved instances.
  - Keywords: parse rtl, design model, elaborate, clock domains, ports
  - Replay: eu_rtlparse $RTL -top $TOP  ; -o design_model.json
- **`eulint`** (:8005, MCP :9005) — RTL lint (SpyGlass). AI-powered RTL lint using SpyGlass Lint.
  - Does: Runs SpyGlass Lint, parses the violation database, and uses the LLM to classify and prioritise with suggested fixes.
  - When: After parse; on any new or changed RTL.
  - Needs: Workspace + IP; SpyGlass licence and tool.
  - Check: Zero blocking lint; triaged warning buckets; flagged structural issues.
  - Keywords: lint, spyglass lint, rtl lint, violations, triage
  - Replay: spyglass -project lint.prj  ; -goal lint/lint_rtl
- **`eucdc`** (:8004, MCP :9004) — CDC verification (VC SpyGlass). AI-powered CDC verification using Synopsys VC SpyGlass.
  - Does: Runs VC SpyGlass CDC, ingests the violation report, and classifies crossings by scheme and severity with LLM context.
  - When: After lint; whenever clocks or resets change.
  - Needs: Workspace + IP; VC SpyGlass; clock/reset intent.
  - Check: Crossings by scheme; unsynchronised crossings; missing-sync count.
  - Keywords: cdc, clock domain crossing, vc spyglass, metastability, sync
  - Replay: vc_static -f cdc.tcl -cdc
- **`eucdc_advisor`** (:8006, MCP :9006) — CDC waiver advisor. Advises and manages CDC waivers with a three-tier policy.
  - Does: Reviews CDC violations against history, proposes and justifies waivers, and enforces a three-tier policy — auto, review, block.
  - When: After CDC analysis; during closure.
  - Needs: A CDC violation report; waiver history.
  - Check: Justified waiver set; blocked items; net real-crossing count.
  - Keywords: waiver, cdc waiver, advisor, justify, closure
  - Replay: eu_cdc_advise crossings.json  ; --policy 3tier

### RTL Lead — `eu_rtl_lead` on :8010 (Static analysis)
Coordinates four RTL agents over one workspace, threading the synthesised netlist into
equivalence — lint readiness, CDC soundness, a gate netlist, then RTL ≡ gate proof.

Chain: lint -> CDC -> synthesis -> equivalence

Example prompt: "Run lint, CDC and synthesis on counter_ip, then prove equivalence"

Page: https://edautils.ai/domains.html?d=rtl

- **`eu_lint_analyzer`** (:8030, MCP :9030) — RTL lint + AI triage. Catches RTL coding issues early and triages them by severity.
  - Does: Runs Verilator --lint-only and Yosys structural checks, parses and classifies the warnings, then groups, prioritises and suggests fixes per violation bucket.
  - When: First RTL static step — on any new or changed RTL, before CDC and synthesis.
  - Needs: Workspace + IP set; elaboratable RTL; verilator and yosys on PATH.
  - Check: Zero blocking lint errors; triaged warning buckets; flagged latches, width mismatches and blocking/non-blocking misuse.
  - Keywords: lint, rtl lint, verilator lint, lint triage, coding style, warnings
  - Replay: verilator --lint-only -Wall  ; -Wno-fatal $RTL ; yosys -p "read_verilog $RTL; ; hierarchy -top $TOP; check"
- **`eu_cdc_formal`** (:8031, MCP :9031) — Structural + formal CDC. Detects clock-domain crossings and proves or refutes CDC properties.
  - Does: Builds a structural clock-domain model from Yosys JSON, finds async crossings missing a two-flop synchroniser, and runs formal (SymbiYosys / BMC) on the CDC properties.
  - When: After lint, before synthesis — and whenever clocks or resets change.
  - Needs: Workspace + IP; clock/reset intent declared; yosys and sby on PATH.
  - Check: List of CDC crossings; unsynchronised crossings; formal property pass/fail.
  - Keywords: cdc, clock domain crossing, 2-ff sync, metastability, cdc formal, structural cdc
  - Replay: yosys -p "read_verilog $RTL; ; prep -top $TOP; write_json soc.json" ; eu_cdc_struct soc.json -o crossings.json ; sby -f cdc.sby
- **`eu_synthesis_run_and_analyzer`** (:8032, MCP :9032) — Yosys synthesis + analysis. Synthesises RTL to a gate-level netlist and reports structure and area.
  - Does: A Yosys-based synthesis runner: RTL → gate-level netlist with cell, DFF and latch reports, ready for equivalence, DFT and area review.
  - When: Once lint and CDC are clean — to produce a netlist for equivalence, DFT or area.
  - Needs: Workspace + IP; Liberty / tech libraries declared; yosys on PATH.
  - Check: Synthesised netlist; cell count; DFF and latch counts — unexpected latches are a red flag.
  - Keywords: synthesis, yosys synth, gate netlist, area report, cell count, dff latch
  - Replay: yosys -p "read_verilog $RTL; ; synth -top $TOP -flatten; ; dfflibmap -liberty $LIB; abc -liberty $LIB; ; stat; write_verilog netlist.v"
- **`eu_equiv_checker`** (:8033, MCP :9033) — RTL ≡ gate equivalence. Proves the synthesised netlist is logically equivalent to the source RTL.
  - Does: Verifies a synthesised gate-level netlist against its source RTL with yosys-eqy or SymbiYosys; handles flatten-before-scan-tie for DFT netlists.
  - When: After synthesis, and after DFT scan-tie — before sign-off.
  - Needs: Workspace + IP; RTL and gate netlist present; eqy or sby on PATH.
  - Check: Equivalence PASS; any counterexample; flatten-before-scan-tie correctly applied.
  - Keywords: equivalence, lec, rtl vs gate, eqy, formal equivalence
  - Replay: eqy run equiv.eqy   # gold=RTL gate=netlist ; # or: sby -f equiv.sby ; # DFT: flatten BEFORE scan-tie

### DFT Lead — `eu_dft_lead` on :8045 (Design-for-Test)
Coordinates four DFT agents over one shared workspace, threading each agent's collateral
into the next — scan readiness, memory BIST, ATPG coverage, then a stitched test top.

Chain: scan lint -> MBIST + ATPG -> integration

Example prompt: "Run the full DFT flow on soc_top, target 95% coverage"

Page: https://edautils.ai/domains.html?d=dft

- **`eu_dft_scan_lint`** (:8047, MCP :9047) — DFT-DRC + scan configuration. Catches testability killers before scan insertion and proposes a muxed-flop scan configuration.
  - Does: Runs DFT-DRC checks — latches, combinational loops, async resets, uninitialised flops, gated clocks — augmented with Yosys check/scc/stat and Verilator lint, then emits a scan-chain config proposal.
  - When: First DFT step — on any RTL you intend to make scannable.
  - Needs: Workspace + IP set; elaboratable RTL; yosys and verilator on PATH.
  - Check: Zero un-waivable DFT-DRC violations; proposed scan-chain count and length; flagged combinational loops.
  - Keywords: scan, dft drc, scan chain, scan insertion, testability, combinational loop
  - Replay: yosys -p "read_verilog $RTL; ; hierarchy -top $TOP; ; check -assert; scc; stat" ; verilator --lint-only -Wall $RTL
- **`eu_dft_mbist_gen`** (:8046, MCP :9046) — March C− MBIST generator. Generates synthesizable memory self-test from a memory spec.
  - Does: Generates a synthesizable March C− MBIST/PBIST controller and per-memory BIST wrappers from a memory spec — name, width, depth.
  - When: When the design has embedded memories needing at-speed built-in self test.
  - Needs: Workspace + IP set; a memory spec declared in the IP; yosys for the elaborate check.
  - Check: Controller and wrappers elaborate cleanly; March C− sequence present; wrapper count matches the spec.
  - Keywords: mbist, pbist, memory bist, march c-, memory test, bist controller
  - Replay: eu_mbist_gen --spec mem_spec.yaml  ; --algo march_c_minus -o mbist/ ; yosys -p "read_verilog mbist/*.v; ; hierarchy; check -assert"
- **`eu_dft_atpg`** (:8048, MCP :9048) — Stuck-at ATPG + fault coverage. Generates test patterns and measures stuck-at fault coverage.
  - Does: Synthesizes the design to a clean BLIF with Yosys (dfflegalize + abc -lut), runs quaigh stuck-at ATPG and fault simulation, and reports fault coverage, pattern count and collapsed faults.
  - When: After the scan configuration is settled — to qualify test coverage ahead of sign-off.
  - Needs: Workspace + IP; quaigh on PATH; a gate netlist; EXCLUDE_CELLS to blackbox memories.
  - Check: Fault coverage against target; pattern count; collapsed-fault count.
  - Keywords: atpg, stuck-at, fault coverage, test patterns, fault simulation, quaigh
  - Replay: yosys -p "synth; dfflegalize; ; abc -lut 4; write_blif soc.blif" ; EXCLUDE_CELLS=RAM* quaigh atpg  ; --fault stuck soc.blif -o pat.test ; quaigh faultsim soc.blif pat.test
- **`eu_dft_integration`** (:8049, MCP :9049) — DFT test-top assembly. Stitches every DFT deliverable into one test top.
  - Does: Consumes the scan, MBIST and ATPG collateral from the other DFT agents, stitches the scan chain and assembles a DFT test top; applies the flatten-before-scan-tie equivalence fix.
  - When: Final DFT step, once scan lint, MBIST and ATPG have produced their collateral.
  - Needs: Workspace + IP; upstream DFT collateral present; the equivalence checker available.
  - Check: Assembled dft_test_top.v; scan-chain continuity; equivalence pass.
  - Keywords: dft integration, scan stitch, mbist hookup, test top, dft top, test wrapper
  - Replay: eu_dft_integrate  ; --scan scan_cfg.json --mbist mbist/  ; --atpg pat.test -o dft_test_top.v ; eu_equiv soc.v dft_test_top.v --flatten

### DV Lead — `eu_dv_lead` on :8012 (Verification)
Orchestrates eighteen verification agents — testplan and testbench generation, build,
regression, triage and debug, formal, and the coverage-closure loop — over one workspace.

Chain: testplan -> generate -> run -> triage -> coverage

Example prompt: "Generate a testbench for counter_ip, run regression and close coverage"

Page: https://edautils.ai/domains.html?d=dv

- **`eu_testplan_generator`** (:8026, MCP :9026) — Testplan from spec. Generates a requirement-traced testplan spreadsheet from the design spec.
- **`eu_testcase_generator`** (:8027, MCP :9027) — Test case stubs. Turns testplan rows into runnable test case stubs.
- **`eu_testbench_generator`** (:8029, MCP :9029) — Verilator testbench. Generates the Verilator testbench for the IP or SoC.
- **`eu_pyuvm_tb`** (:8043, MCP :9043) — PyUVM environment. Generates a PyUVM testbench with functional covergroups.
- **`eu_build_compile`** (:8013, MCP :9013) — Build + compile. Builds and compiles the design and testbench, including firmware hex.
- **`eu_regression_run`** (:8022, MCP :9022) — Regression run. Runs the regression suite with parallel execution and seed control.
- **`eu_gls_sim_run`** (:8024, MCP :9024) — GLS simulation. Runs gate-level simulation against the synthesised netlist.
- **`eu_rtl_vs_gls_regression_analyzer`** (:8014, MCP :9014) — RTL vs GLS analysis. Compares RTL and gate-level regression results and analyses XPASS.
- **`eu_regression_triage`** (:8015, MCP :9015) — Regression triage. Categorises regression failures by root cause and dispatches them to debug agents.
- **`eu_regr_debug`** (:8016, MCP :9016) — Log compare debug. Diffs failing against passing simulation logs to localise the divergence.
- **`eu_waveform_debug`** (:8017, MCP :9017) — Waveform analysis. Analyses waveforms for CDC crossings and protocol compliance, and compares against a baseline VCD.
- **`eu_rtl_debug`** (:8020, MCP :9020) — RTL debug. Deep RTL analysis — NBA conflicts, FSM issues and protocol pitfalls.
- **`eu_rtl_fix`** (:8021, MCP :9021) — RTL fix generation. Generates the RTL fix and checks its blast radius before proposing it.
- **`eufv_genai`** (:8018, MCP :9018) — SVA property generation. Auto-generates SystemVerilog assertions tied to the design's requirement IDs.
- **`eu_formal_property`** (:8019, MCP :9019) — Formal proof. Proves the generated properties with SymbiYosys and parses counterexamples.
- **`eu_coverage_analyzer`** (:8028, MCP :9028) — Coverage analysis. Measures feature, test, functional, line, branch, toggle and requirement coverage, and writes results back to the testplan.
- **`eu_coverage_closure`** (:8041, MCP :9041) — Coverage-closure loop. Ranks coverage holes and decides reseed against add-test to drive coverage to target.
- **`eu_crv_stimulus`** (:8042, MCP :9042) — Constrained-random stimulus. Reseeds structural holes with constrained-random stimulus using reproducible seeds.

### Signoff Lead — `eu_signoff_lead` on :8011 (Sign-off & packaging)
Validates and packages a verified IP for hand-off — checking it against the design model and
emitting a schema-valid IP-XACT deliverable.

Chain: verified collateral -> IP-XACT package

Example prompt: "Validate and package counter_ip as IP-XACT"

Page: https://edautils.ai/domains.html?d=signoff

- **`eu_ip_package`** (:8040, MCP :9040) — IP-XACT packaging validation. Validates and packages a verified IP as IP-XACT.
  - Does: Checks the IP against the IP-XACT schema, verifies ports, registers and parameters against the design model, and emits a packaged, sign-off-ready deliverable.
  - When: Final step — after RTL, DV and DFT sign-off, before hand-off.
  - Needs: Workspace + IP; verified collateral; IP-XACT schema.
  - Check: Schema-valid package; matched ports and registers; no unresolved parameters.
  - Keywords: ip package, ip-xact, packaging, deliverable, signoff
  - Replay: eu_ippkg counter_ip  ; --validate --ipxact  ; -o counter_ip.xml

### Cross-cutting services

- **`help_assistant`** (:8025, MCP :9025) — /help slash-command backend. Answers how-to and capability questions, in context, on every surface.
  - Does: A standalone help assistant behind the /help slash command and @help routing; synthesises answers with per-Lead domain context.
  - Endpoint env var: HELP_ASSISTANT_URL
- **`eu_design_knowledge`** (:8044, MCP :9044) — Hardware-aware dual-store RAG. Grounds every agent in authoritative, revision-scoped design knowledge.
  - Does: Splits a structured store (IP-XACT, register YAML, SDC — with authority dedup and hash-skip) from a semantic mesh. A query router sends exact register and SDC facts to the authoritative store and design intent to semantic retrieval. Ranking boosts exact-phrase and tag hits above word overlap, and structured facts outrank semantic matches. Model-keyed vector stores let an embedding model be swapped or A/B tested without corrupting retrieval.
  - Endpoint env var: EU_DESIGN_KNOWLEDGE_URL
- **`eu_token_dashboard`** (:8050, MCP :9050) — Per-user multi-LLM metering. Meters and governs token usage across users, offices and LLMs.
  - Does: Instruments the LLM router chokepoint — every call routes through it — attributes usage to user, office and flow, applies budgets, and serves an authenticated global dashboard using OpenTelemetry GenAI conventions.
  - Endpoint env var: EU_TOKEN_DASHBOARD_URL

## Evidence

None of this is a claim you have to take on trust. The checks ship with the bundle and run
on your machine.

- 16,047 tests green — 0 failed, 0 skipped, 804 files
- 262 runnable example manifests — 85 per-agent, 177 usage-mode
- 56 services accounted for by status_all.sh
- 3 eval suites, 21 cases, comparable across backends

- Golden-file regression on planner inference, so a prompt change that moves a plan is caught.
- Lead coverage-parity checks across every Lead, so one domain does not quietly fall behind.
- Static lints on Lead parsers, under a second, before anything else runs.
- Every example is syntax-checked without services, and executed with them.

## About EDAUtils

EDAUtils has shipped free SoC-integration, IP-XACT and RTL tooling from Bangalore since
January 2012 — 38 tools, 50,000+ downloads, 200,000+ recorded tool usages, users at Intel,
Texas Instruments, NVIDIA, Samsung, Broadcom, Qualcomm, Renesas, Ciena and 40+ more
semiconductor companies. The AI SDK is what that decade of flow work turned into.

Founder: Kanai Ghosh — Founder, EDAUtils · Bangalore, India.
Kanai started in EDA in 1998 and has spent close to three decades in EDA tool and CAD flow
and methodology development, deployment and support, with professional exposure across NXP,
Intel, Qualcomm, Texas Instruments, Interra and Delsoft. After years building other people’s
tools he started building his own, nights and weekends around the day job. edautils.com went
live in January 2012 and the tools have been free from the first day.

The focus was always the same place the effort and the errors concentrate. A modern SoC can
carry more than 250 pieces of IP across multiple power and voltage domains, with constraints
moving under the designer while power, performance and area trade against the project
budget. Integration is where that bites, and integration is what Baya automated.

Baya was built on the IEEE 1685-2009 IP-XACT standard, in GUI and Tcl command modes from the
start, with a low-level API onto the design database and a design-maturity report from
unconnected pins and ports. It had 100+ Tcl commands then; it has 200+ now, and reads
IP-XACT 1685-2009, 1685-2014 and 1685-2022.

Alongside it came Brigid — VHDL and Verilog parsers, testbench generators, vhdl2verilog and
verilog2vhdl, verilog2systemc and vhdl2systemc, clock and reset tree extraction, RTL
sorting, encryption for IP protection, and a hierarchy and module-dependency browser. That
collection is the RTL utilities today.

Which is the honest origin of this SDK. Fourteen years of driving real flows with real tools
against real netlists taught us what an agent has to be grounded in before its answer is
worth anything. The AI SDK is that knowledge, wired to a planner: one layer above every
vendor’s tools, extensible by the methodology team that has to live with it.

### FAQ

**Who is behind the EDAUtils AI SDK?**
Kanai Ghosh, an EDA and CAD tool developer based in Bangalore, India, who launched
edautils.com in January 2012 and has built and supported EDA tooling since 1998.

**How does the AI SDK relate to the free EDAUtils tools?**
The free tools at edautils.com — Baya, the IP-XACT suite, the RTL utilities — remain free
and unchanged. The AI SDK is a separate, self-hosted orchestration and knowledge layer that
can drive those tools alongside Synopsys, Cadence and Siemens tools in a single plan.

**Is the AI SDK self-hosted?**
Yes. It runs inside your network against a local model server or your own provider keys.
Design collateral, learned knowledge and usage metering all stay in your deployment.

**Does it replace my existing EDA tools?**
No, and it is not trying to. It is the layer above them. It runs Verilator, Yosys,
SymbiYosys and quaigh natively, and drives registered vendor tools over MCP using your
existing licences.

**Can my team add its own agents?**
That is the point of the SDK. eu-ai create-agent writes three files, a run.py entry point is
three lines, and the behaviour lives in an EU_SKILL.md markdown file rather than in code.

**What does it cost to try?**
A conversation. Tell us the flow you want to run and the tools you own, and we will tell you
honestly whether this helps before anyone installs anything.

## Contact

- Technical support: help@edautils.ai — Flows, agents, bugs, bring-up and deployment questions.
- The free tools: help@edautils.com — Baya, IP-XACT, the RTL utilities and everything on edautils.com.
- Licensing and commercial: sales@edautils.com — Pricing, licensing, premium support and custom development.

We aim to answer within 24–48 hours on business days. Put URGENT in the subject if a
deployment is blocked.

### What we can help with

- **Evaluation and bring-up** — A walkthrough on a design your team already knows, on your own tools.
- **Joint debug session** — Screen-share on a flow that is not behaving — with the people who wrote the agent.
- **A new agent for your methodology** — Tell us the tool and the policy; we will scaffold the agent or show your team how.
- **Deployment sizing** — One server for a team, a Flow Manager plus per-domain hosts at scale, or laptop mode with no farm at all.
- **Premium support** — Response commitments and a named contact for your organisation.
- **Source and API examples** — Python, Tcl and Java examples against the parser and knowledge APIs.

## Related EDAUtils products

- Free EDA tool suite (https://edautils.com/): 38 free tools for SoC integration,
  IEEE 1685 IP-XACT packaging and RTL manipulation — Baya (`baya-shell`), the IP-XACT suite
  (`ipxact-shell`), parsers, translators, testbench and document generators, UPF and VCD.
  Install one with: curl -fsSL https://edautils.com/install.sh | sh -s -- <tool-name>
- Browser versions of the same tools: https://edautilsonline.com/