ONTOLOGY.md

ONTOLOGY.md

ChipDev is the context layer for chip design agents. Scroll to see how it works.

 

A reasoning agent needs more than a database.

To debug one failing test it needs the coverage, the spec, the bug thread and how the last engineer worked it out.

In most chip teams, that lives in ten systems that don't talk.

UCDB files, regression logs, Jira, spec PDFs, email. None of it is AI ready.

We bring in every kind of data an agent reasons over.

Tables, text, context, and the reasoning traces from past debug sessions.

Tables come in typed.

Every column has a type, a unit and a grain, so an agent can't sum coverage at the wrong level.

Everything keeps its source.

File, version, time pulled and export class, on every row, paragraph and trace.

The same signal often has three names.

rst_n in the RTL, reset in the spec, sys_rst in the bug thread.

We link them to one term, across tables and text.

The coverage rows, the spec paragraph and the bug discussion now all point to one reset.

Some links have to be reasoned out.

No table says which requirement a test was written for. A model reads the test, the plan and the commit, proposes the link and keeps its evidence.

A model drafts the definitions and the reasoned links.

Each one carries the evidence behind it. It's a draft until someone signs it.

Your engineers review and sign.

Each metric and each link is signed by its owner, at each milestone.

Change the definition and it needs a new signature.

The old one doesn't carry over. Every change is logged.

> which tests went stale when REQ-4.2 changed?

SELECT t.name, t.last_pass, r.versionFROM test tJOIN testplan_link l ON l.test_id = t.idJOIN req_version r  ON r.req_id = l.req_idWHERE r.req_id = 'REQ-4.2'  AND r.valid_from > t.last_pass;

2 tests last passed before REQ-4.2 v3: t_fifo_full, t_reset_seq.cited: spec §4.2 p.41 · PRJ-812 triage · plan row 14resolved: Requirement, Test, Testplan Link · example data

> what was yield on lot 7?

check_answerable → coverage 0.3 · no term covers "yield"

This data has no fab yield source, so I can't answer that. I can show test escapes by block instead, or you can connect the MES.

Every answer shows its evidence.

The terms it resolved, the typed query it ran, and the spec and bug text it cited.

If the evidence isn't there, the agent says so.

In a tapeout review, “I don't know” beats a confident wrong number.

An agent that works in the demo can break a month later.

Long context, a stale spec, a three-day triage, a model upgrade nobody re-tested.

So we judge it on evidence, not confidence.

“The agent says it's done” doesn't count. A signed-off question that passes does.

Every change re-runs the checks.

New model, tool or schema: we re-run your questions and show what was expected and what the agent saw.

Your flow will change, and the context has to keep up.

New tools, new milestones and new models all change what the data means.

That's why we stay on after the build.

Care keeps the data and the agents right, all year.

 

ChipDev is the context layer for chip design agents.

Reasoning agents need more than tables. To answer a real question about a chip, an agent needs typed tables, the text around them, the context that connects them and the reasoning traces from past work. ChipDev brings all of it together on your network, links it by meaning, has your engineers sign the definitions, and keeps checking that the agents on top still get the right answers.

Four kinds of data, one layer

A debug question crosses all four. “Why does t_fifo_full fail on gate 3?” needs the coverage table, the spec paragraph for the full flag, the block's owner and milestone, and the notes from the last time someone debugged that FIFO.

TABLES    coverage, regressions, bugs, timing, licences
          typed: every column has a type, a unit and a grain

TEXT      specs, test plans, bug threads, review comments, waivers
          split by section and linked to the terms it mentions

CONTEXT   IP hierarchy, owners, milestones, configurations
          the structure that connects everything else

TRACES    debug sessions, triage notes, agent runs
          kept with their outcome, found by failure signature

We tie them together two ways. Semantically: rst_n, reset and sys_rst resolve to one term, so the rows, the paragraph and the bug thread meet in one place. And by reasoning: where no system records a link (which requirement was this test written for?), a model proposes one, shows its evidence and waits for an engineer to sign it.

Where it sits in your agent stack

Agents usually fail for reasons a better prompt won't fix. Either the agent can't see what it needs, or nothing checks its answer, or a multi-step job has no shape. ChipDev supplies the chip-specific part of each layer.

HARNESS   what the agent can see and do
          a map of your chip, typed MCP tools, memory of past
          debugs, policy walls it can't argue with

LOOP      how it knows it's right
          your signed-off questions, as checks that can fail

GRAPH     what happens next
          gate packs: checks run in parallel, each step has an
          owner, and a person signs the step that can't be undone

Which problem do you have?

It can't find the spec section behind a failing test
Text isn't linked to the tables
It treats rst_n and reset as different signals
No shared terms
Its coverage number doesn't match your dashboard
Untyped tables, wrong grain
It retries a debug approach that already failed last month
No reasoning traces
It says “done” and you still have to check
No signed-off checks
It got worse after a model upgrade and nobody noticed
Nothing re-runs on change

What we sell

Connectors
Pull tables, text and traces from the systems listed below into your own environment. Tables land typed, text is split by section, and everything keeps its source and policy labels (export class, IP owner, NDA scope).
Chip domain pack
A starting ontology of about 30 chip terms (block, IP, requirement, test, bug, waiver, corner and so on) with synonyms, relationship contracts and metric definitions. Stored in the open Apache Ossie format, so you can take it with you.
Linker
Links rows, paragraphs and traces to the same terms. Where no system records a link, a model proposes one with its evidence, and it waits for sign-off.
Sign-off
Your leads review each definition and each reasoned link, and sign it at each milestone. A changed definition has to be signed again.
Gates
Multi-step decisions built as graphs: tapeout readiness, regression triage, ISO 26262 traceability, compute and licence spend. Checks run in parallel, and a person signs the step that can't be undone.
Assurance
We re-run your signed-off questions on every model, tool or schema change, test long-context and long-running tasks, and track drift, refusals and policy leaks.

What we connect to

Bugs and changes
Jira, git, Perforce, Gerrit, GitHub
Regressions
Jenkins, GitLab CI, LSF and Slurm accounting, simulator logs, vManager and Verisium exports
Coverage
UCIS XML exports, URG reports
Specs and documents
PDF and Word specs, Confluence, design review notes
Requirements and test plans
ReqIF, Jama, Polarion, spreadsheet test plans
IP and hierarchy
IP-XACT, Perforce IPLM, filelists
Debug history
Bug comments, triage notes, agent session traces
Static checks
Lint, CDC, RDC and formal report summaries, waivers
Physical design
Timing, power and QoR summaries by corner
Compute and licences
FlexLM and RLM logs, job accounting

If your system isn't listed, ask. Most flows export something we can parse.

How an engagement works

  1. 1. Agent-Readiness Assessment

    2 weeks, fixed fee

    We collect about 30 questions your leads actually ask, connect one or two sources in a sandbox, and check how many of those questions an agent can answer correctly today. You get that score, a list of the gaps and a plan to close them.

  2. 2. Foundation Build

    6 to 10 weeks

    We deploy on your infrastructure, set up 3 to 5 connectors, load the domain pack, link your text and traces, and run sign-off sessions with your DV and PD leads. We're done when your question set passes. At the end you have an MCP endpoint any agent can use.

  3. 3. Gate packs

    2 to 4 weeks each

    Tapeout readiness, regression triage, ISO 26262 traceability, and compute and licence spend.

  4. 4. Care

    annual

    We keep connectors working as your tools change and get definitions re-signed at each milestone. On the agent side, we re-run your questions on every change, test long-context and long-running tasks on your real use cases, and audit what agents do through MCP. You get a named engineer.

What we promise

  • It runs on your infrastructure, with self-hosted models if you want them. Your data doesn't leave your network.
  • Agents get read-only access by default. Anything that writes, like filing a bug, adding a waiver or starting a re-run, is a separate tool with its own permissions and its own log.
  • It works with any agent: Claude, Cursor, your own, or your EDA vendor's. You own the context layer.
  • Policy labels (export class, IP owner, licence and NDA scope) stay attached to every row, paragraph and trace, and they're enforced where agents connect.

What we can't promise: we make sure the context is right, and we measure how any agent performs on it. We can't change the internals of a third-party agent.

Open standards

Agents connect over MCP. The ontology exports in the open Apache Ossie format. We work with the chip standards you already have: IP-XACT, UCIS, ReqIF and the ISO 26262 traceability chain.

Who it's for

VPs of engineering, DV and infrastructure leads, CAD and methodology owners, and functional-safety managers. It doesn't matter whether you buy agents from your EDA vendor, build your own, or just let engineers use Claude and Cursor. They all need the same context underneath.