Point Your AI IDE at Your Own Silicon Tools — Locally, No Cloud

One command connects your AI assistant to real DRC, LVS, and timing engines running on your own machine. Your design never leaves your laptop. The engines stay deterministic. The agent just drives.

July 6, 2026 • By Shivaram Mysore

The agentic moment — for silicon, on your machine

AI assistants can now use tools, not just talk about them. Give an agent a set of tools and it will call them, read the results, decide the next step, and call them again — the loop that makes coding assistants feel less like autocomplete and more like a teammate. That shift is formalized in MCP, the Model Context Protocol: a standard way for agents to discover tools, call them, and consume structured results.

Chip design should get the same loop. But there's a catch nobody in silicon can ignore: your RTL, your layout, your PDK are the crown jewels. Most cloud-hosted "AI EDA" products require shipping design data to their servers. For many teams — anyone under an NDA, an export rule, or a healthy sense of self-preservation — that's a non-starter.

So we built the other thing. With Vyges™ Loom, your AI IDE drives real sign-off engines that run on your own machine — locally, with no cloud and no authentication. Nothing is uploaded. Nothing leaves your box.

One command: vyges mcp

Loom is a suite of open, Rust-native sign-off engines — DRC, LVS, static timing with signal integrity, and more. You already install them in one shot:

vyges install loom

Now expose them to your AI IDE:

vyges mcp setup

That's it. vyges mcp speaks the Model Context Protocol — the open standard AI assistants use to call tools, the same protocol Claude Code and Cursor already understand — and advertises each installed engine as a tool your agent can invoke. Ask your assistant to "run DRC on this GDS against the sky130 deck installed locally" and it calls the drc tool, the engine runs on your machine, and structured results come back for the agent to reason about. Same for timing, LVS, and the rest.

No port opened, no localhost server, no auth, no network. It's your own binaries, exposed to your own agent, on your own machine — the same trust model as any local developer tool.

loom.feedback — the agent's eyes

A layout-debug loop needs more than a pass/fail. So Loom ships loom.feedback: one call that returns a rendered image of the layout, categorized DRC verdicts grouped by rule, and a quality score — optionally correlated against a golden reference.

vyges mcp feedback design.gds --rules sky130.drc

An agent calls loom.feedback, sees what the layout looks like and exactly what's wrong and by how much, makes an edit, and re-runs — closing the loop the way a human engineer would. It's the difference between a tool an agent can call and a tool an agent can debug with. The exact contents depend on the engine and rule deck you point it at, but the interface an agent sees is always the same shape.

Why local + deterministic is the whole point

Two properties make this trustworthy for real silicon:

• Local. Your design data stays on your machine. That's not a feature flag — it's the architecture. There is no server to send your netlist to, because the tools already live in ~/.vyges on your box, and the server your IDE talks to is a plain local subprocess — no socket, no port.
• Deterministic. The AI is a driver on top, never inside the engines. The DRC, LVS, and timing math are the same reproducible results whether an agent invokes them or your build script does. Pull the agent out and the exact same flow still runs, headless, in CI. You get the speed of an agentic loop and the reproducibility a tapeout demands.

That combination — agentic on the outside, deterministic and local underneath — is the one cloud-required tools can't offer.

Works with the IDE you already use

vyges mcp setup detects the AI IDEs on your machine — Claude Code, Cursor, and VS Code — and registers Loom with each, safely (it never disturbs your other tools' configuration). No plugin required — these editors speak MCP natively, and so does anything else that's MCP-compliant. Prefer to do it per project, or point a single assistant at it by hand? Those work too. Open your project, and the engines show up as tools.

Get started

# 1. Install the open Loom engines (once)
vyges install loom

# 2. Wire them into your AI IDE   (takes under a minute)
vyges mcp setup

# 3. Open your project in Claude Code / Cursor / VS Code
#    and ask your assistant to run DRC, close timing, or debug a layout.

It's free, it's open, and it runs where your design already lives. The agentic loop has come to silicon — without leaving your laptop.

Loom is Apache-2.0 and part of the Vyges toolchain. Install it with vyges install loom.