Packagent

Inspiration

Everyone is building AI for chip design right now. RTL, verification, layout, timing, all of it. Almost nobody touches packaging, which is strange, because ever since chiplets showed up, packaging is where the performance actually comes from. Sign-off there is still spreadsheets, tribal rules, and someone manually cross-checking a 2000-ball map. We wanted to see if a coding agent could close a loop in that world, a physical one, through real commercial EDA tools. And we wanted to build it so it couldn't quietly lie to us. In packaging, a hallucinated design rule doesn't cost you an afternoon. It costs you a mask set.

What it does

Packagent puts a Codex agent (running GPT-5.6) on top of our verification toolkit and a real EDA stack, then lets it work a genuinely broken package:

It solves the design in Ansys SIwave and finds the power network resonating at 1824 Ω where the spec allows 200.
It reads the physics and figures out why: plate capacitance under 1 pF, which means the design has no working reference planes at all. Then it does something we honestly didn't expect. It predicts the fix's capacitance in writing (51 pF plus fringing) before ever running the solver. Measured afterward: 61 pF.
It draws the missing copper into the actual Cadence database. Headless, through SKILL, and every edit gets re-checked in a fresh session before we trust it.
It re-solves. 1824 Ω drops to 74 Ω, a 96% reduction, and the mask passes.
Then the part we're proudest of. Give it a second requirement that conflicts with the first, and it tries three fixes. An independent referee rejects all three, because each one quietly traded away a spec. So it stops, reports the conflict with evidence, and ships nothing.

The receipts are real: 26 solver-signed result trees, runs that reproduce bit-identical three times over, and our own open-source physics oracle lands within 3.68% and 1.00% of the commercial solver's resonance peaks.

How we built it

The unglamorous half is pkgtk, a deterministic verification toolkit we built first, before any AI. Ball-map connectivity checks, semantic ECO diffs, geometry lint, Touchstone gating, PDN physics. Every command is a headless CLI with a strict exit-code contract and JSON output, because that's what an agent can actually be trusted to drive.

The agent half is OpenAI Codex on GPT-5.6, wired in properly rather than prompted ad hoc. There's an AGENTS.md operating manual, a project config layer with specialist subagent roles, repo skills for the verification and headless-EDA workflows, and an eval harness of 28 seeded-defect tasks with zero-LLM graders, so when we change how the agent is instructed we can measure the difference instead of eyeballing it.

Our house rule the whole way through: no agent-written code merges without a human-authored golden fixture we computed by hand, and any gap in coverage gets flagged loudly instead of passing silently.

Challenges we ran into

Headless EDA fought us constantly. Cadence's batch mode aborts with a misleading "No licenses available" if you pass the wrong product flag. A batch SKILL exit auto-saves your dirtied design with no prompt, which is how we learned to only ever work on copies. There's an undocumented four-column format where getting the order wrong doesn't error, it just silently writes you an empty GDS. And the official Cadence-to-Ansys translator needs a license our server doesn't carry, so we had to find a bridge through IPC-2581 instead.

The hardest part wasn't making the agent fix things, though. It was making the refusal path trustworthy: building a referee the agent can't argue with, graded on physics rather than on the agent's own confidence in itself.

What we learned

An agent is only as good as the deterministic layer underneath it. Give GPT-5.6 a tool surface with real contracts and an independent referee, and it can close a loop across two commercial EDA tools that has never been closed autonomously. Just as importantly, it stops when it should. An agent you can't bluff is the only kind you'd let anywhere near a tape-out.

What's next

Net-aware spacing checks, COM channel compliance, live rule-extraction from spec PDFs, and growing the eval harness into a proper continuous tuning loop for the agent itself.