IP Nirmaan
Website: https://ip.nirmaan.online
An AI-native semiconductor IP company, as software. IP Nirmaan is an
organizational operating system for semiconductor engineering. Give it a
requirement ("Create a 4-port AXI-to-NoC bridge") and a machine-readable
company plans the work: divisions, teams, and roles from Intern to CEO, with
skills, authority, gates, and a 12-article constitution. Every task gets an
owner, an independent reviewer, an authorized approver, evidence requirements,
and an escalation path, and each routing decision records why it was made.
nirmaan plan "Create a 4-port AXI-to-NoC bridge." --detail
nirmaan demo all
nirmaan why <project> microarchitecture
The task engine keeps planned, executed, verified, and approved distinct, and
it makes a fake tool run or a self-approval impossible. Language models will
power workers who fill seats in the organization. They get no special access
and cannot mark their own work verified. Design:
docs/NIRMAAN_ORG_OS.md.
The platform
| Component | What it is | Entry point |
|---|
IP Nirmaan organizational OS (src/nirmaan/) | The company as data, the task engine, the orchestrator, and the agent runtime interface | nirmaan |
VeriTriage (src/veritriage/) | The verification-intelligence engine: evidence graphs, knowledge packs, reasoning, regression memory | veritriage |
IP Nirmaan is bigger than verification, and it builds on VeriTriage's
verification technology rather than replacing it:
- VeriTriage investigations are real, evidence-producing tools inside Nirmaan's task engine.
- VeriTriage's 44 Knowledge Packs are the domain knowledge that Nirmaan's skills cite.
- VeriTriage never depends on Nirmaan, so it stays usable as a standalone verification tool.
VeriTriage: the verification engine
Verification intelligence for semiconductor regression debug. VeriTriage turns
raw verification artifacts (simulation logs, compile logs, coverage summaries,
test metadata) into a normalized Evidence Graph, a deterministic failure
classification with confidence and evidence, an engineering-grade HTML report,
and suggested next debugging steps - in one command. A Verification
Knowledge Engine ships 44 pluggable Knowledge Packs across six domains
(interconnect, CPU/ISA, memory, serial IO, coherency, and methodology):
AMBA AXI/APB/AHB/ACE/AXI-Stream, CHI, TileLink, OCP, Wishbone, NoC, PCIe,
CXL, UCIe, DDR, HBM, USB, Ethernet, MIPI, I2C/I3C, SPI, UART, JTAG, UVM methodology with
RAL/phasing/TLM, SVA, formal, low power, DFT, X-propagation, CDC, reset,
coherency, security, performance, and RISC-V depth (100 deterministic failure
patterns, 98 debug playbooks, 17 protocol state machines total) that match the
evidence against known failure patterns, project it onto protocol state
machines to show where progress stopped, and attach deterministic debug
playbooks with real specification references. An Agent Framework then puts
eight domain specialists over the deterministic result, merging their
evidence-backed positions into ranked findings with agreement and conflict made
explicit. Every analysis is also recorded into a persistent Regression
Database, so the platform tells you whether this failure has been seen
before, what resembled it, and what the historical root cause was. A
Learning Engine then turns that accumulated history into reusable
knowledge: recurring patterns, evidence combinations, per-specialist
reliability, and project memory, all derived deterministically and all linked
back to the investigations they were learned from. Finally a Planning
Engine turns all of it into a structured, branching investigation plan:
what to inspect next, what evidence would confirm or reject each hypothesis,
what it costs, and how you will know when you are done. A Design
Intelligence Engine underpins all of it with a structural understanding of
the system: a Design Graph of modules, interfaces, clock and reset domains,
address regions, and verification components, joined by typed relationships
and derived deterministically from the project model. A Conversation
Engine finally makes all of it navigable: grounded, structured questions
whose every statement cites an artifact that already exists. Generative AI
sits above all of it as a rendering layer only: providers turn structured
findings into prose, grounded by enforcement rather than by request, and never
touch a conclusion. An Automation Engine finally makes the platform react:
it publishes the events it already detects, evaluates declarative rules against
them, and requests follow-up work. It observes and decides; it never executes.
veritriage analyze simulation.log coverage.txt test_metadata.json
Why VeriTriage
Today's debug flow after a regression failure is manual: open the log, grep for
errors, open the waveform, inspect signals, form a hypothesis. VeriTriage
automates the front half of that loop:
This is the beginning of the README. Read the rest at the original. Read the full README ↗
