For IG-XL test engineering teams

An AI agent working live on your IG-XL program.

ATE·IQ's agent works beside the program you have open. It reads every sheet, the live VBA with your unsaved edits and the cell you are on; it answers from your spec, load board and production data with tools that compute rather than recall; and it stages edits you preview, apply and revert in the workbook. Around it sits the whole test-engineering loop — spec to program, board and production data — checked by machine on your own machine.

Request a walkthrough See the IG-XL agent →
  • Follows the program you have open, in Excel or loaded in IG-XL.
  • Every edit is previewed, applied on your click, and reversible.
  • The Excel add-in installs per user with no admin rights. ATE·IQ runs on your machine, and project data goes only where you point it: your LLM provider and any repository, Jama server or model endpoint you connect.
ATE·IQ Live Workbook following Example_Program.xlsm open in Excel: the Flow sheet and the tfIq_3V3_Active procedure ticked in the program tree, the procedure's VBA in the viewer, and the agent's answer giving the Use-Limit row the test is judged against, test 400, 0 to 6E-05 A
Live Workbook, following a program open in Excel. Two items ticked and one question asked: the agent explains the procedure from the VBA editor and reads its limit off the live Flow sheet, including the 60 µA limit applied from the Excel pane a few minutes earlier. Captured on an invented example program.

What you can ask it

The questions an IG-XL engineer brings every day — answered from the program in front of you and the data behind it.

Edit mode

“Tighten this limit to 60 µA.”

“This limit” is the cell you are on. The agent stages the change on the row IG-XL reads limits from, shows the before and after, and waits for your Apply. Revert puts it back.

Edit mode

“What does this VBT procedure do?”

It reads the module's current source from the open editor, unsaved edits included, and looks up IG-XL API and instrument facts in its built-in knowledge before it proposes a VBA change.

Debug mode

“Did the spec's new limits reach the program and the lots?”

It sets the spec, the program's flow limit and the limit each lot ran side by side, from the same reconcile the traceability dashboard uses, and names who owns each mismatch.

Debug mode

“Why is this lot failing?”

It reads the STDF — yield by site and bin, first-fail paretos, per-test Cpk and outliers — with deterministic tools, and builds a cause chain for the test you name.

Debug mode

“Will this program compile?”

It runs ATE·IQ's offline pre-flight checks on the open program and lists what it checked, and what only IG-XL itself can confirm.

Quality tab

“Review this VBA.”

Thirty-three rules review the modules, with findings at the exact line and a development or production profile to match the stage you are at.

The agent window opens in Edit mode, with the IG-XL knowledge tools and the workbook editor. Switch to Debug and it has all 35 tools and the project behind it. Live VBA, unsaved edits included, needs Excel's VBA project access, which the add-in installer turns on for your user. The agent's tools, and so its staged edits, need an Anthropic model today; with another provider the chat answers without them.

Verdicts are computed, never recalled.Every join between spec, program, board and production is a deterministic engine. The agent calls those engines and explains what they return.
IG-XL offline simulator
25 / 25 · Bin 1
datalog rows as predicted, from a generated 16-test program run by IG-XL itself¹
spec vs program
1 of 16 flagged
the one limit the program never followed¹
VBA review
33 rules
findings at the exact line, in Excel and on synced programs

¹ Demonstration project for a small motion sensor with a 4-wire SPI interface: synthetic data with defects planted on purpose. The simulator run is a proof build — one site, simulated instruments, reads filled from the device model — so it is not a tester result.

The IG-XL agent

It works where the program lives.

Click Open Agent on the ATE·IQ tab in Excel and the agent's window opens beside the workbook. While it is connected, the add-in streams the sheets and your cursor every few seconds and re-reads the VBA editor's current state as you work, so answers and edits start from what is on your screen, not from a stale saved copy. With a test program loaded in IG-XL, it has streamed the live sheets, VBA and cursor too.

The ATE·IQ agent window beside Excel on Example_Program.xlsm: asked to tighten the upper limit of Iq_3V3_Active to 60 µA, it stages a one-cell change on the Flow sheet's Use-Limit row, 7.5E-05 to 6E-05 at Flow!L14, with Dismiss and Apply buttons
The agent's window beside Excel. Asked to tighten a limit, it stages the one-cell change on the Use-Limit row IG-XL reads, says what the new limit means for the program, and waits for your Apply. Same example program.

Test programs

From the spec to a program the tester can run.

A datasheet, a requirements spreadsheet or a Jama Connect project becomes structured requirements with limits, forced conditions and test numbers. From those, ATE·IQ drafts a complete IG-XL project — sheets, VBT modules, digital patterns — checks it, repairs it, judges it against a model of the device, and can run it on IG-XL's own offline simulator. AI-written VBA is checked against the IG-XL API before you see it.

Pattern Generator waveform of an example SPI write followed by a read: clock, data in, data out and chip select, with compare strobes on the read
The Pattern Generator's live waveform for an example write and read, each address and data cycle labelled with its frame phase and bit. An example transaction, not a pattern from a customer program.

Load boards

Read the board your EDA tool wrote. Check it against the program.

Allegro netlist and Fabmaster exports import natively, with no Cadence licence; IPC-2581, ODB++, Specctra DSN, KiCad and PDF schematics too. Every pin in the program's pin map is checked against the board's nets, the copper is measured, the 166-rule DIB check runs, and a DC operating-point check reports rail voltages at the DUT before the board is ever powered. Layout stays in your EDA tool; ATE·IQ never draws copper.

A real Allegro board, read from its Fabmaster export, in the layout tab at 3x zoom
Pin match · demonstration pin map 15 / 16 tester pins resolve on the board INDEX is the planted miss: the pin map names it, and the board has no net or pin for it.
A real Allegro 17 board, read from its public Fabmaster export, checked against a demonstration pin map that carries one planted miss.

Production data

The ground truth, parsed where it lands.

STDF V4 lots parse natively on the engineer's machine — yield by site and bin, Cpk, drift, wafer maps and outlier screens. The traceability dashboard joins every lot back onto the program and the spec and names the limit one of them no longer shares, and lot statistics become limit proposals that are never written for you.

Wafer map of a demonstration wafer: fails concentrated around the rim, and a lower-right cluster marked by the detector
Wafer 1 of the demonstration wafer-sort lot (synthetic data). Fails around the rim are the planted edge signature; the dashed box is a cluster the detector marks, and it also marks clusters on wafers where none was planted.

Everything in the box

Four pillars, and one agent across all of them.

Agent

Live program context

Sheets, VBA with unsaved edits and your cursor, streamed while you work.

 Agent

Edits you approve

Fields, cell blocks and whole VBA modules — previewed, applied on your click, reversible.

 Agent

IG-XL knowledge in your own assistant

The IG-XL knowledge tools also run as an MCP server for the AI assistant your team already uses.

 Test programs

Spec to IG-XL project

Sheets, VBT and patterns keyed to the spec's test numbers, checked and repaired before you see them.

 Test programs

AI-written VBA, checked

Generated and suggested VBA is checked against the IG-XL API and known instrument rules.

 Test programs

Judged by a device model

A model derived from files you have, or your own model connected over ATE·IQ's protocol, with a kit to check the connection.

 Load boards

The formats your EDA tool exports

Allegro netlist and Fabmaster, IPC-2581, ODB++, Specctra DSN, KiCad and PDF schematics, read natively.

 Load boards

Checks before first power

Pin match, the 166-rule DIB check, copper DRC and a DC operating-point solve of the board's rails.

 Load boards

Board exports

Gerber and Excellon, a fab package, BOM, pick-and-place, KiCad and Specctra DSN, generated from the imported design.

 Production data

STDF on your machine

Yield, bins, Cpk, paretos, outlier screens and wafer maps from the binaries themselves.

 Production data

Spec, program and lots, checked for agreement

Limit drift between the three is named, with the artefact that owns each number.

 Platform

Local-first, your LLM

Runs on the engineer's machine with Anthropic, an OpenAI-compatible gateway or Azure OpenAI, on your keys.

How it fits your flow

A production test program is never one file: the limits live in a spec, the program in an IG-XL workbook, the board in your EDA tool and the proof in STDF files. ATE·IQ keeps all four in one workspace, joins them mechanically, and puts the agent where the engineer already works.

SPEC datasheet · Jama PROGRAM + AGENT IG-XL · VBT · Excel BOARD schematic · channel map COPPER layout · DRC · fab PRODUCTION STDF · yield · Cpk lot statistics → proposed limits (never auto-applied) every hop reconciled — a limit, pin or net that drifts is flagged with its owner named
Fig. 1 — The loop. Each hop is reconciled by a deterministic engine; the agent sits with the program, where edits happen, and can reach every pillar's tools.

Shown on the demonstration project

The test-program and production figures on this site come from one demonstration project: a small motion sensor with a 4-wire SPI interface, taken from a structured spec to a program IG-XL ran, and on to nine STDF files of synthetic production data with defects planted on purpose — so every finding can be checked against what was put there.

Demonstration project · a small motion sensor with a 4-wire SPI interfacesynthetic lots · planted defects
  1. Spec16 requirements6 DC parametric · 10 SPI functional, each with limits and a test number
  2. Program10 IG-XL sheets · 16 tests · 12 pattern filescross-sheet validation 0 failures, 1 advisory · bench pre-flight clean
  3. Device model16 / 16 replayed clean · 80 compare cycles, 0 mismatchesa stand-in derived from the register map and a transcribed electrical pack
  4. IG-XL simulator25 / 25 datalog rows as predicted · Bin 1offline simulator, proof build: one site, simulated instruments, model-filled reads
  5. Traceability16 / 16 joined spec → program → lot · 1 compliance errorthe planted guard band the program never followed · presence on test number, not correctness
  6. ProductionSite 3 at 79.2 % against 93–96 % on the other sitesthe first of three final-test lots, where a socket leak was planted
Yield by site in a demonstration final-test lot: sites 1, 2 and 4 between 93 and 96 per cent, site 3 at 79.2 per cent in red
Yield by site in the first final-test lot, as ATE·IQ draws it. The site-3 drop is the planted socket leak.

Boundaries

Offline is labelled offline: IG-XL remains the compile authority, and a simulator run is not a tester result. Proposals stay proposals: limit proposals never write a limit, and workbook edits wait for your Apply. Missing data says so: a surface without its inputs reads awaiting data, not "clean". The prose is the model's: the tools compute their figures deterministically, but the answer around them, tables included, is written by the language model you configured, so check a figure that matters against the tool. It does not draw copper: ATE·IQ reads, views and verifies the load board; layout stays with the EDA tool that drew it.

Talk to us

The useful first conversation is a walkthrough on your device and your tester: a spec you already ship, a workbook you already maintain, and the agent working in that workbook. Tell us what you are working on and we will reply within one business day.

Request a walkthrough sales@ateiq.io