# 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

## 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`

## Domains — one Lead each

- [Infrastructure Lead](https://edautils.ai/domains.html?d=infra) — `infra_orch` on :8008, 2 agents. Stands up a chip project from nothing — a convention-correct workspace tree, then the environment and per-domain flow settings.
- [Integration Lead](https://edautils.ai/domains.html?d=integration) — `eu_soc_lead` on :8034, 9 agents. 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.
- [FECAD Lead](https://edautils.ai/domains.html?d=fecad) — `fecad_orch` on :8000, 4 agents. 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.
- [RTL Lead](https://edautils.ai/domains.html?d=rtl) — `eu_rtl_lead` on :8010, 4 agents. Coordinates four RTL agents over one workspace, threading the synthesised netlist into equivalence — lint readiness, CDC soundness, a gate netlist, then RTL ≡ gate proof.
- [DFT Lead](https://edautils.ai/domains.html?d=dft) — `eu_dft_lead` on :8045, 4 agents. 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.
- [DV Lead](https://edautils.ai/domains.html?d=dv) — `eu_dv_lead` on :8012, 18 agents. Orchestrates eighteen verification agents — testplan and testbench generation, build, regression, triage and debug, formal, and the coverage-closure loop — over one workspace.
- [Signoff Lead](https://edautils.ai/domains.html?d=signoff) — `eu_signoff_lead` on :8011, 1 agents. Validates and packages a verified IP for hand-off — checking it against the design model and emitting a schema-valid IP-XACT deliverable.

## Cross-cutting services

- `help_assistant` on :8025 — /help slash-command backend. Answers how-to and capability questions, in context, on every surface.
- `eu_design_knowledge` on :8044 — Hardware-aware dual-store RAG. Grounds every agent in authoritative, revision-scoped design knowledge.
- `eu_token_dashboard` on :8050 — Per-user multi-LLM metering. Meters and governs token usage across users, offices and LLMs.

## Why this and not a vendor copilot

- 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

## Pages

- [Overview](https://edautils.ai/) — the product in one page
- [How it works](https://edautils.ai/architecture.html) — tiers, knowledge layer, governance, extensibility
- [Domains](https://edautils.ai/domains.html) — per-Lead flows and agents
- [Agent explorer](https://edautils.ai/agents.html) — every agent, port, keyword and replay command
- [Downloads](https://edautils.ai/downloads.html) — install steps and access requests
- [About](https://edautils.ai/about.html) — EDAUtils since 2012
- [Contact](https://edautils.ai/contact.html) — help@edautils.ai
- [llms-full.txt](https://edautils.ai/llms-full.txt) — the complete machine-readable description
- [data/sdk.json](https://edautils.ai/data/sdk.json) — the site's own content source, as JSON