# ONTOLOGY.md

ChipDev is the context layer for chip design agents.

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.

## 1. Bring it together

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.

```
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
```

## 2. Link it by meaning

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, so the coverage rows, the spec paragraph and the bug discussion 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.

## 3. Sign off

A model drafts the definitions and the reasoned links. Each one carries the evidence behind it, and 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, and every change is logged.

```
coverage_closure(block, gate) = covered bins / testplan bins
grain:    block × milestone gate
excludes: waived bins (with waiver id)
0 bins → null, never 100%
```

## 4. Show the evidence

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.

## 5. Keep agents right

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.

## End of file

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.

---

## The details

### 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?

| Symptom | What's missing |
|---|---|
| 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

| Area | Sources |
|---|---|
| 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. **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. **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. **Gate packs** (2 to 4 weeks each). Tapeout readiness, regression triage, ISO 26262 traceability, and compute and licence spend.
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.

Contact: hello@chipdev.ai · Training data for chip AI: https://chiptrain.ai
