Boost Front-End SoC Design With Defacto’s AI-Powered Tool

Front-end SoC design has always been a balancing act between speed, accuracy, and the large amount of manual work required to get RTL, IPs, and collaterals to be aligned. In a recent webinar, Defacto CEO and founder Chouki Aktouf joined by product manager Valentin Boyer, walked through how the company is bringing AI directly into its SoC Compiler platform, and showed, in real time, just how far a single human-language prompt can now take a design team.

25 Years of EDA, Now AI Powered

Defacto has been in the EDA business for close to 25 years, building design automation solutions for front-end designers with offices around the world. Its flagship product, Defacto’s SoC Compiler, is already used daily by thousands of designers across many of the top 20 semiconductor companies, helping teams build subsystems and top-level architectures while managing RTL, IP, and design collaterals.

The focus of this webinar wasn’t the core tool itself, though, it was what the team calls Defacto’s SoC Compiler AI, an AI layer that’s been running in production for over a year. The goal was simple: make the tool accessible enough that a junior engineer can pick it up in a day and build complex applications, while still giving expert users a way to speed up their existing workflows.

What Teams Are Actually Using It For

Rather than a single flashy feature, Defacto described a set of real, everyday applications customers are already running:

• Automatic top-level connectivity generation through natural language prompts
• Design introspection, extracting data, parsing information, and reporting on existing blocks or objects
• Version comparison between different design iterations
• Specification generation or extraction from existing design projects
• File list management to help design flows interoperate across tools
• Error analysis and correlation to support debugging

All of these capabilities are delivered as agent skills which are self-contained behaviors paired with the scripts (needed to interpret and execute user requests).

Supporting the Full Design Lifecycle

One of the clearest points made during the session was that this isn’t an additional feature for a single task. It’s meant to support teams end to end, from flow setup through active use and debugging.

In other words, that means:

1. Specification extraction at the start of a new project, helping teams reuse and update specs quickly
2. Flow setup, including generating or adapting file lists from RTL inputs
3. Active building and management, such as assembling subsystems, running and monitoring tasks, and managing registries or memory maps
4. Debugging and guidance when something goes wrong
5. On-the-fly training and tutorials, generated dynamically rather than relying on the static documentation that ships with traditional EDA packages

Instead of digging through static tutorials, users can ask the tool to generate custom use cases and guidance tailored to what they’re actually trying to do.

Three Ways to Use It

Defacto outlined three usage models that customers combine depending on their workflow:

• Chatbot mode : for quick questions like “which command helps me do this?” without digging through documentation
• Interactive mode : where the tool runs in the background and users issue direct requests like “check this report for me” or “build this for me.” This is where Defacto sees the most usage of its MCP server.
• IDE-integrated mode : plugging into environments like VS Code or Cursor to edit, update, or generate scripts from scratch, which can then be run against the tool

Under the hood, the AI runs as an MCP server that connects to internal LLMs (commercial models or open source alternatives). Defacto handled the validation work behind this: qualifying LLM behavior with customers to prevent hallucinated commands or inconsistent results before any skill ships to end users.

The Demo: From One Prompt to a Fully Integrated SoC

The most compelling part of the session was Valentin Boyer’s live demonstration using a Claude Code client inside VS Code. The prompt was intentionally simple:

“Assemble the SoC from the RTL defined in source directory. Then wrap the two CPUs together and generate the output result.”

From that single instruction, the tool:

1. Generated a file list, scanning the RTL directory and resolving dependencies using SoC Compiler’s native parsing
2. Built and ran assembly scripts, translating the specification file into a documented, reviewable Python script that called SoC Compiler APIs directly
3. Restructured the hierarchy, wrapping the two CPUs together and automatically recreating connections, no manual configuration file edits required
4. Generated an HTML report, flagging an unconnected port and documenting the hierarchy before and after the change

Throughout the process, the model verified its own results at each step and could pause to ask clarifying questions whenever a decision required user input. The entire flow: file list, assembly, reconfiguration, and reporting, ran with no manual scripting from the user, and every generated script remained fully visible and editable.

Why It Matters

The main idea of the webinar was that AI, layered on top of a mature EDA tool, isn’t about replacing designers, it’s about reducing the turnaround time between an idea and a verified result. Tasks that used to require manual scripting, careful file list management, or digging through documentation can now be described in plain language, executed transparently, and reviewed step by step.

For teams already using Defacto’s SoC Compiler, the message was clear: the underlying tool hasn’t changed, but the interface to it just got a lot more direct, a lot faster to learn and complex design tasks such as building pre synthesis a complex SoC can trully be realized by a simple prompt human directive!

The replay of the webinar is accessible on the Defacto website: https://defactotech.com/news/499-webinar-defacto-is-boosting-front-end-soc-design-with-ai-powered-eda-tools

Also Read:

See Defacto Technologies at DAC 2026

WEBINAR: Defacto is Boosting Front-end SoC Design With AI-Powered EDA tools

Webinar: Faster Design Spec to Implementation using IP-XACT