Store causal models and incident evidence, compute deterministic risk analytics, and know exactly when every answer is still valid.
BUILT ON FOUNDATIONS ENGINEERS TRUST
Each one has a structural cause. IngaDB removes the cause instead of patching the symptom.
PROBLEM
The model lives in a drawing tool, the incidents in a spreadsheet, the numbers in a report—and nobody can say which of the three is current.
SOLUTION
IngaDB keeps the model, the evidence, the computation, and the revision history in one queryable system, behind one HTTP API.
PROBLEM
The same system is redrawn once per hazard, and each drawing drifts from the system it describes the moment it is finished.
SOLUTION
Describe the mechanism once—failure modes, propagation, redundancy—and compile the tree each hazard implies. Provenance names the facts behind every gate, and the compiler reports every branch it stopped at, and why.
PROBLEM
A different analyst, tool version, or random seed shifts the figure — and if an LLM is doing the arithmetic, every run invents a new one. When an audit asks for the basis, not being able to rebuild the original computation is the real risk.
SOLUTION
Fixed traversal order, empirical-Bayes estimation from recorded incidents, and a constant Monte-Carlo seed: the same inputs always produce the same numbers, and the recorded input revision lets you rebuild the original computation any time.
PROBLEM
Evidence keeps arriving and topology keeps changing, but last quarter's numbers keep circulating with nothing to mark them as expired.
SOLUTION
Every analysis is stamped with its input revision. When the model or the evidence changes, IngaDB returns the exact delta that made the answer stale.
PROBLEM
Ask an agent about failure probability and it improvises a plausible number, because it has no causal store to query.
SOLUTION
The retrieval API and ingactl give agents deterministic, revision-stamped answers—search, causal paths, evidence, importance, cut sets—with dry-run before execute.
IngaDB doesn't just return a number. It returns what the number rests on, and where the model's competence ends.
Each result ships with its own audit trail, as data.
The write path is guarded so results stay defensible.
Three capabilities, one pipeline: model the causal structure, quantify it from evidence, and keep every computed answer honest about its age.
Represent events and AND/OR gates as typed graph data. Compile fault trees from failure modes, propagation paths, and redundancy facts without redrawing them.
Compute cut sets, empirical-Bayes probabilities, importance measures, and fixed-seed uncertainty bands. The same inputs produce the same numbers.
Every analysis is stamped with its input revision. When evidence or topology changes, IngaDB returns the exact delta that made the answer stale.
The conversation belongs to the agent; the computation to the deterministic engine. What-if runs without touching stored data, stamped with its revision.
Verified by the engine: halving seal leak lowers the top event "line stops" from 4.94% to 4.07%. Nothing stored was touched.
Same inputs, same answer — 4.07% (revision 42). No improvised numbers.
Our failure-knowledge platform, Causation, structures trouble reports and maintenance records with AI and quantifies countermeasure effects with a calculation engine — running in production on the same causal engine as IngaDB, with the same division of labor: AI extracts, people approve, a deterministic engine computes.
hozen.cognitech.dev — the actual fault-tree screenThat was the core of IngaDB. Worked examples, architecture placements, and measured performance are covered in detail in the documentation.
Five perspectives on one project — including turning report piles into evidence with an AI agent.
Read the examples →02Beside a monitoring stack, under your own application, between documents and agents.
See the placements →03Measured latency by graph size, with boundaries reported as numbers. Reproduce command included.
See the numbers →04The catalog-driven ingactl — it can even emit SKILL.md / AGENTS.md artifacts for your agents.
Meet the CLI →Causal effect reasoning is one form of world model—in a limited scope. IngaDB serves that scope as data: mechanisms of how systems fail, compiled into fault trees, quantified from recorded incidents, and stamped with the revision they were computed from. And the model knows where it ends—every compiled tree names the exact branches the compiler stopped at, and why.
The same inputs produce the same numbers, every run.
Probabilities come from recorded incidents, with their basis attached.
Every answer reports where the model's competence ends.
Everything you need to decide whether IngaDB fits your stack. Anything else, write to [email protected].
A causal analysis database. It stores fault-tree models and the incident evidence recorded against them, computes deterministic risk analytics—cut sets, probabilities, importance measures, uncertainty bands—and tracks which results are still valid as models and evidence change.
From recorded incidents, by empirical-Bayes estimation. When an event has little evidence of its own, its estimate is pooled across the workspace—and every probability reports the basis it was derived from.
No. Describe the system once as mechanism facts—failure modes, propagation paths, redundancy—and compile the fault tree each hazard implies. The compile is read-only, names the facts behind each gate, and reports every branch it stopped at, and why.
Every analysis is stamped with the revision it was computed from. After a change, IngaDB tells you whether a result is still fresh and, if not, returns the exact delta—which facts, incidents, or topology edits—made it stale.
Yes. The command catalog that documents the API also drives ingactl, so an agent can sync the catalog, read each route's contract and required permission, dry-run, then execute. Retrieval routes cover search, causal paths, evidence, importance, and cut sets—every answer deterministic and revision-stamped.
Self-hosted, on your own infrastructure: one binary beside PostgreSQL 16, two containers with the bundled Docker Compose file. API keys, RBAC, and an audit trail are built in, and typed TypeScript and Python clients are generated from the OpenAPI contract.
Bring causal models, evidence, and revision-aware analytics into your stack.