In April 2023, an early RapidGPT prototype turned a natural-language request into Verilog, ran the design through Xilinx Vivado, and programmed it onto a physical board. The example was simple, but it demonstrated a broader idea: an AI system could generate code, operate engineering tools, and carry work through to a verifiable result.
Over the next two years, we expanded RapidGPT beyond context-aware HDL generation to include EDA tool execution, waveform analysis, and project-wide file operations. As those workflows grew more sophisticated, the limits of its Visual Studio Code extension architecture became clear. Long-running processes had to follow the host application’s APIs and lifecycle, while production hardware workflows often ran elsewhere: on remote Linux infrastructure, through terminals, schedulers, and tightly controlled compute environments.
RapidGPT needed to move beyond the IDE. We needed an environment-agnostic platform built for command-line operation, remote execution, persistent project state, and deeper integration with enterprise EDA infrastructure.
That platform became NEX.
As NEX evolved, we defined five principles to guide how we built and extended it. We call them the CHASE principles: Composable, Hierarchical, Adaptable, Secure, and Extensible.
Decoding CHASE
Each CHASE principle addresses a recurring challenge in applying AI to semiconductor engineering workflows.
C — Composable
Agents, tools, and skills combine to form complex engineering workflows.
Silicon development spans many activities, from RTL modification and verification to simulation, synthesis, timing analysis, and project automation. NEX represents its capabilities as modular building blocks that can be assembled into different workflows rather than embedding them in a fixed sequence.
Tools provide access to files, commands, EDA applications, and project infrastructure. Skills capture reusable instructions and engineering knowledge. Agents combine these capabilities to pursue broader objectives.
Teams can combine these building blocks according to the task. One workflow might bring together repository analysis, RTL changes, simulation, and waveform inspection, while another combines capabilities for synthesis or FPGA implementation.
H — Hierarchical
Specialized agents coordinate through structured delegation.
Large hardware projects contain far more context than any single task needs. RTL, verification environments, constraints, scripts, generated files, and architectural documentation may all matter at different stages.
NEX uses hierarchical orchestration to divide that complexity. Manager Agents interpret the overall objective and delegate focused tasks to specialized Domain and Task Agents, such as agents responsible for RTL implementation, verification, timing, or a specific EDA environment.
Each agent can therefore work with the context and tools relevant to its responsibility, while the overall workflow remains coordinated and inspectable.
A — Adaptable
The same workflow can operate across toolchains, environments, and model providers.
Semiconductor workflows vary widely across organizations and projects. Teams use different EDA tools, compute environments, target technologies, and AI models.
NEX supports these differences by integrating with commercial and open-source EDA environments across FPGA and ASIC workflows, operating locally or on remote Linux infrastructure, and working with different model providers.
This portability allows teams to choose tools and models based on capability, infrastructure, cost, latency, or data-governance requirements without redesigning the surrounding workflow.
S — Secure
Deployment and execution must respect the sensitivity of semiconductor IP.
RTL, netlists, constraints, verification environments, and implementation data are highly sensitive assets. For many organizations, moving them outside existing security boundaries is not acceptable.
NEX is therefore designed to operate entirely within those boundaries. It supports private deployment models, including fully on-premises and air-gapped environments, and can run directly where repositories, EDA tools, licenses, and compute resources already reside.
In fully isolated environments, NEX requires no external connectivity. No analytics or telemetry are collected, and license activation can be performed entirely offline. When paired with locally hosted models and infrastructure, design data can remain within the organization’s compute perimeter throughout the workflow.
E — Extensible
Teams can add proprietary capabilities that NEX does not provide out of the box.
Every semiconductor organization has internal scripts, wrappers, regression systems, infrastructure, and engineering conventions that a general-purpose platform cannot anticipate.
Teams can extend NEX with internal utilities through structured tool interfaces. Custom skills and project-level instructions add engineering knowledge, repository conventions, and tool-specific procedures.
NEX can also be embedded into existing automation through its non-interactive execution modes. Teams can invoke agent workflows from scripts, CI pipelines, regression environments, or other orchestration systems without requiring an interactive terminal session.
An organization might, for example, give NEX access to its regression launcher, compute scheduler, proprietary lint flow, or internal IP-management system.
Efficiency in Practice
An agent’s trajectory is the sequence of steps it takes to solve a problem: inspecting files, gathering context, calling tools, making changes, and validating the result. Its efficiency depends on the time, tokens, and cost required to reach a correct solution.
The CHASE principles guide how NEX builds these trajectories. Composable capabilities let agents combine the tools and skills a task requires, while hierarchical delegation helps focus each step on the relevant context. The aim is to reach a validated result with less unnecessary exploration, repeated work, and context overhead.
Repository-level engineering tasks offer a practical way to measure the resulting resource use and task success. We evaluated NEX on HWE-Bench, a large bug-repair benchmark spanning multiple hardware repositories and bug categories. For this experiment, we narrowed the scope to a single repository: the lowRISC Ibex RISC-V CPU core. We evaluated all 35 repository-level bug-repair tasks from that subset. These tasks require the agent to inspect a real repository, identify the cause of a failure, modify the relevant implementation, and validate the result using the project’s native simulation and regression flows.
The benchmark includes issues involving pipeline behavior, trap handling, CSR compliance, and Physical Memory Protection logic. We compared NEX with two well-established coding agents: Anthropic’s Claude Code and OpenAI’s Codex. For this experiment, NEX used Gemini 3.1 Pro, Claude Code used Claude Opus 4.8, and Codex used GPT-5.5.
The results are summarized in Figure 1.
These figures capture the resource use and outcomes of each system’s trajectories, including the effects of model selection, context construction, tool use, orchestration, retries, and validation.
Comparable task resolution with fewer input tokens
NEX resolved 33 of the 35 tasks, matching Claude Code and exceeding the 31 tasks resolved by Codex.
At the same time, NEX processed 24.81 million input tokens, approximately 41.4% fewer than Claude Code and 44.3% fewer than Codex.
Input-token volume measures the cumulative model input across a trajectory. NEX’s lower total is consistent with its approach to context management: scoping context to the agents and stages that need it. The comparable task-resolution result shows that lower input-token use did not come at the expense of observed repair success in this evaluation.
Faster end-to-end execution
NEX completed the full 35-task evaluation in 1.90 hours, compared with 2.35 hours for Codex and 2.81 hours for Claude Code.
End-to-end execution time includes much more than model latency. Repository exploration, command execution, simulation, retries, context construction, and orchestration all contribute. The result therefore reflects the efficiency of the overall trajectory rather than inference speed alone.
Lower estimated API cost
We calculated API costs by accounting separately for input tokens, cache reads, cache writes, and output tokens, applying the corresponding API rates published on each vendor’s official website as of August 2026.
NEX’s estimated API cost for the benchmark was $21.90, compared with $47.20 for Claude Code and $45.25 for Codex. That places NEX at roughly half the estimated API cost of both alternatives while matching or exceeding their observed task-resolution rate.
Taken together, the results show more resource-efficient trajectories for NEX on this Ibex evaluation: comparable repair outcomes with fewer input tokens, lower estimated API cost, and shorter end-to-end execution time. This is the kind of efficiency the CHASE principles are designed to support.
From Principles to Efficient Trajectories
Moving beyond the IDE wasn’t simply a change in interface; it required rethinking how our agentic framework should operate inside real semiconductor engineering environments.
The CHASE principles have guided that evolution, with efficient agent trajectories as a central goal. NEX’s results on Ibex illustrate why this matters: reaching comparable repair outcomes with fewer resources makes automation more practical for everyday engineering work.
