NanDigits

GOF AI / AGENTIC DESIGN WORKFLOWS

Describe the task.
Put GOF to work.

Turn design intent into GOF scripts and results. Use natural language to drive netlist ECO, investigate non-equivalence, or generate RTL from a specification—from the agentic CLI you already use.

See a request become a script Request an evaluation license

Works with Claude Code, Codex, opencode, Kimi, Cline, and pi through the shipped GOF Skill.

YOUR AGENTIC CLI + GOFSKILL.md

You describe the task

Use GOF to do ECO spec file
$GOFDIR/examples/ai_eco/eco_spec1.txt
  1. 01
    The agent prepares the scriptDesign files, libraries, top module, constraints
  2. 02
    GOF runs the design operationThe generated script executes through gof -run
  3. 03
    You inspect the resultECO outputs, reports, and schematic context

A standard GOF workflow, driven by your intent.

START WITH THE DESIGN PROBLEM

Less API lookup.
More time on the design.

You know what needs to change. GOF AI helps translate that intent into the API calls, scripts, and tool runs needed to act on it.

01 / NETLIST ECO

Describe the change.

Insert a gate, reconnect a pin, or apply an RTL change to an implementation netlist. Supply the design context and let the agent prepare the GOF flow.

“Insert a type X4 inverter into stop/glue/u0 pin A.”
Natural language ECO example →

02 / DEBUG & VERIFICATION

Investigate the mismatch.

Run LEC, open an instance in a schematic, or ask the AI agent to investigate a non-equivalent point using the reference and implementation designs.

“Debug the non-equivalent point u_abc/my_ctrl_reg.”
See how the debug loop works →

03 / SPEC TO RTL

Turn requirements into RTL.

Generate Verilog RTL from a specification or describe a targeted update to existing RTL. Use candidate scoring to guide review and selection.

“Convert this specification to Verilog RTL.”
Explore the spec-to-RTL flow →

For each task, provide the relevant files, libraries, top module, and constraints. The examples above describe the intent; the complete ECO request below shows the design context.

A WORKED EXAMPLE / RTL-GUIDED ECO

From a design request
to a script you can inspect.

The shipped SKILL.md includes examples that map natural language to GOF APIs. Here, the request defines the RTL change, target netlist, and design constraints.

1. Tell the agent what to run

Use GOF to fix netlist $GOFDIR/examples/ai_eco/imp_net.v
Set LLM effort 5
The library is $GOFDIR/examples/ai_eco/art.m.simple2.LIB
The original RTL is $GOFDIR/examples/ai_eco/imp_rtl.sv
The new RTL is $GOFDIR/examples/ai_eco/ref_rtl.sv
The top level module name is testtop
Set test_mode to constant zero
Do not use library cells matching *_1P0 T_*

Example paths refer to the GOF installation. Substitute your own files for a project run.

2. GOF executes the generated script

The agent prepares a Perl script that reads the libraries and RTL, compares the designs, loads the implementation netlist, applies the constraints, and runs the ECO.

gof -run eco_script.pl
  • ECO script to inspect and reuse.
  • Updated Verilog netlist for the next stage of your flow.
  • ECO report and design checks to review the changes.

Review the outputs and verify the changed design against the intended reference. GOF supports LEC and schematic inspection as part of that review.

Inspect the example GOF Perl script

This example follows the conversion in the shipped GOF Skill. eco_script.pl is an illustrative filename; the agent can generate a timestamped filename for each run.

use strict;
setup_eco("llm_direct_fix");
set_log_file("llm_direct_fix.log");
read_library("$ENV{GOFDIR}/examples/ai_eco/art.m.simple2.LIB");
set_dont_use("*_1P0", "T_*");
set_llm_effort(5);
read_rtl('-ref', "$ENV{GOFDIR}/examples/ai_eco/ref_rtl.sv");
read_rtl('-imp', "$ENV{GOFDIR}/examples/ai_eco/imp_rtl.sv");
set_top("testtop");
rtl_compare();
read_design("-imp", "$ENV{GOFDIR}/examples/ai_eco/imp_net.v");
set_top("testtop");
set_pin_constant("test_mode", 0);
fix_design();
report_eco();
check_design("-eco");
write_perl("output_llm_dir_fix.pl");
write_verilog("output_llm_dir_fix.v");
Read the full GOF Skill workflow →

AI-ASSISTED NON-EQUIVALENCE DEBUG

A failing point.
A guided trace to its cause.

When LEC reports a mismatch, the next question is why. GOF AI can investigate a failing point using circuit data and logic values from both designs.

  1. GOF extracts the evidence. Instance and logic-value data from REF and IMP are passed to the agent.
  2. The agent chooses where to trace. It analyzes discrepancies and requests the next circuit context.
  3. The loop builds a diagnosis. Inspect the findings alongside the designs in GOF Debug.
View the non-equivalence debug example →
Two schematic paths with different output values; an additional OR gate is circled in the lower path.
Non-equivalence example from the GOF manual: compare logic values and trace the difference through the circuit. View full size ↗

GET STARTED WITH THE GOF SKILL

Use GOF from your agentic CLI.

Start with a Linux GOF installation and license, plus a supported CLI configured for your AI provider. The shipped SKILL.md gives the agent the GOF workflow and API examples.

  1. Install GOF.

    Request a license, download the release, and set GOFDIR to the directory containing bin/, scripts/, and SKILL.md.

    export GOFDIR=/path/to/GOF64
export PATH="$GOFDIR/bin:$PATH"
    Download GOF →

  2. Connect the GOF Skill.

    Make $GOFDIR/SKILL.md available through your CLI’s skill setup. It tells the agent how to start the GOFAI server, create a run script, and execute GOF.

    See the manual’s setup example →

  3. Describe your first task.

    Ask for an ECO, LEC run, schematic, non-equivalence investigation, or spec-to-RTL conversion. Include your input files and design constraints.

    Use GOF to do ECO spec file
$GOFDIR/examples/ai_eco/eco_spec1.txt
How the GOFAI server and GOF client work together

The server: gofai_server.py wraps the selected CLI platform. Start it once per host and reuse it for subsequent runs.

The client: gof -run <script>.pl runs the generated script in client mode. The agent uses the launch procedure in the shipped skill, including tmux and xterm for a separate run session.

Supported --platform values: claude, codex, opencode, kimi, cline, and pi.

Read the GOF AI Skill article →
Agentic CLI connects through SKILL.md and the GOFAI server and GOF client to the ECO, LEC, schematic, and RTL engines.

TRY IT ON A REAL DESIGN TASK

Bring the intent.
Inspect the result.

Start with a focused ECO or a failing equivalence point. Evaluate how GOF AI fits the work your team already does.

Request a GOF AI evaluation license →Discuss your use case

Go deeper

GOF AI manual chapter →Inspect designs with GOF Debug →Natural language in the GOF shell →GOF AI Skill article →