Your agents do not need more data. They need an ontology that decides what is true.
Rippletide builds your Decision Ontology automatically, from your documents, APIs, vector stores, workflow logs, and evaluated agent traces. Start with one write-action and test it against real scenarios before Runtime integration.
- One scoped Safety Pack in 10 working days. Broader integration and Runtime control are scoped separately.
- Auditable end to end. Every rule traceable to source, timestamped, attributable.
+15 points of agent outcome on average.
In observed deployment work using the Rippletide Decision Ontology, agent task completion rose from approximately 75% to approximately 90% on evaluated production workloads.
Every enterprise has an ontology. Almost none of them know it.
Your business runs on rules. Case closure criteria. Credit pre approval logic. Compliance perimeters. IAM authority. SLA tiers. They live in PDFs, Confluence pages, API schemas, ticketing histories, and in the heads of people who left two quarters ago.
Your agents do not have access to any of that as a coherent model. They have access to fragments, retrieved by similarity, not by applicability. They guess. And when they guess wrong on a ticket closure, a credit decision, or a compliance call, nobody can prove what rule was supposed to apply.
Manual ontology modeling has been the answer for twenty years. It takes six to twelve months, requires a dedicated team, and the moment it ships, it is already stale. Forward deployed engineers do not scale. Static ontologies do not survive contact with reality.
There is a faster path. We build your Decision Ontology automatically, and we keep it honest.
Not a knowledge graph. Not a semantic layer. A Decision Ontology.
Knowledge graphs store what your company knows. Semantic layers align what your company names. Neither tells your agents what to do.
A Decision Ontology stores what your company decides, and under what conditions. It is the typed, versioned, auditable representation of:
Entities
The things your agents can act on: customers, accounts, contracts, tickets, incidents, payments.
Rules
The conditions that govern those actions: thresholds, authorities, exceptions, escalation paths.
Policies
The constraints that surround them: compliance, IAM, contractual obligations, regulatory perimeters.
Outcomes
The verified results that validate them: what worked, what did not, under which conditions.
It is the substrate that makes the difference between an agent that sounds right and an agent that is right.
The Decision Ontology Manifesto
Five principles. The reason this category exists.
Decision first, not description first.
An ontology that does not encode decisions is documentation. Decision Ontologies make the action boundary testable in scenarios today and can support Runtime control as the product expands.
Outcome conditioned.
Rules are derived from evaluated outcomes, not from authored intent. A rule that does not correlate with successful results is a hypothesis, not a rule.
Automatically derived, humanly governed.
Bootstrap by machine. Validate by human. Edit in natural language. The expert’s job is judgment, not modeling syntax.
Living, not laminated.
New policies, APIs, and evaluated traces can produce proposed updates for human review. The decision model is versioned rather than frozen in amber.
Auditable end to end.
Entities, rules, and contradictions stay traceable to their sources, timestamps, and reviewers. The result is evidence for a review, not a blanket compliance claim.
Inject. Structure. Validate. Repeat.
Rippletide Automatic Ontologies runs a closed loop across four stages. Every iteration makes your ontology more complete, more accurate, and more aligned with how your business actually decides.
Inject: Connect any source
The Rippletide engine can ingest documents (policies, contracts, SOPs, runbooks), APIs and system schemas (CRM, ERP, ticketing, payment systems, identity providers), workflow histories, and evaluated agent traces paired with verified outcomes.
A trace without an outcome is a sequence of actions. A trace with an outcome is a learning signal. Rippletide does not learn from noise. It learns from results.
Structure: Derive a candidate Decision Ontology
The Rippletide engine derives a candidate Decision Ontology: entities, typed relationships, rules, validity windows, exceptions. Neuro symbolic reasoning where it matters: LLM based extraction for breadth across heterogeneous sources, symbolic reasoning for type consistency, contradiction detection, and deterministic rule encoding.
Candidate facts retain provenance: the document, clause, API field, or trace that produced them.
Validate: Notion style editor in plain English
A Notion style editor lets your domain experts review and edit the ontology in plain English. No DSL. No SPARQL. No graph query language. The expert writes a sentence; the system encodes the rule deterministically.
When Rippletide is uncertain, because the source documents are themselves ambiguous, it does not guess. It proposes two alternatives, A or B, and asks the human to choose. The choice is encoded. The reasoning is logged.
System of Record Integrity: Contradictions surfaced, routed, resolved
As Rippletide structures sources into a candidate Decision Ontology, it surfaces contradictions. Policy A says one threshold. SOP B says another. The API schema requires a third. The findings stay linked to their sources for the right owner to resolve.
You do not just get an ontology. You get the truth about your documentation.
Contradiction patterns to test in a Safety Pack
| Engagement type | Source scope | Contradiction signal |
|---|---|---|
| Support workflow | Evaluated agent traces | Case closure criteria differ between policy and reviewer practice |
| Credit pre-approval workflow | Documented process and policy | Approval owner differs between the documented process and authority matrix |
| Finance operations workflow | API schemas vs. compliance policy | A required policy field is absent from the system schema |
You do not just get an ontology. You get the truth about your documentation.
Outcomes, not vibes.
The Decision Ontology is not only a research artifact. Today it supports offline decision previews on traces and scenarios. It can later support live Runtime control after the Safety Case is proven.
We measure agents on outcome based evaluation: did the agent complete the task with the expected result, verified against ground truth?
| Configuration | Outcome OK |
|---|---|
| Production agent without Rippletide Decision Ontology | ~75% |
| Same agent with Rippletide Decision Ontology | ~90% |
+15 points on average. Observed across selected customer support, credit decisioning, IT operations, and code generation workloads.
Methodology: outcome-based evaluation on production workloads, scored against verified ground-truth results. This is not a leaderboard benchmark or a guaranteed customer result.
From documentation to decidability.
From broad modeling programs to one scoped Safety Pack
In 10 working days, the team builds and reviews the candidate decision model needed for one write-action. Broader integration and Runtime control are scoped separately.
From stale documentation to living ontology
Evaluated traces and policy changes can produce candidate updates for human review. The model stays versioned, sourced, and open to correction as the business changes.
From “trust me” to reviewable agent decisions
Each tested action is evaluated against typed entities, explicit rules, and verified facts. The decision preview carries an evidence-linked trace for production-owner review.
From fragmented retrieval to applicability
The Decision Ontology feeds the Rippletide Context Graph. Your agents stop retrieving by similarity and start retrieving by applicability, the right context for this action, now.
Eighteen months of R&D. Production deployments. Public proof.
Automatic Ontology generation is the production application of years of neuro symbolic AI research led by Yann Bilien, Rippletide’s Chief Scientist (Imperial College).
Yann presented the approach at the inaugural Context Graph Meetup, hosted with Neo4j in San Francisco on February 26, 2026: “Automatic Ontologies for Trustworthy AI Agents.” The talk covers eighteen months of R&D, production case studies (testing agents on every commit, a credit decision system for a global automotive manufacturer), and the architecture that combines structured knowledge, embedded process, and deterministic enforcement.
The Rippletide engine combines:
- LLM based extraction for breadth across heterogeneous sources
- Symbolic reasoning for type consistency, contradiction detection, and rule encoding
- Outcome conditioned learning from evaluated agent traces
- Human in the loop validation through natural language editing
Backed by published research, production deployments at design partner enterprises, and a runtime engine designed for SOC 2, GDPR, and CCPA control environments.
Where Decision Ontologies pay back, in weeks.
Every use case below is structured around a single question: where do agents make consequential decisions today, and how does an automatic Decision Ontology make the action boundary explicit and reviewable faster than manual modeling could?
Customer Support
Case closure, escalations, entitlements.
- Typical scope: Tier 1 support automation, case closure, entitlement changes, and escalations.
- Review signal: required evidence and escalation criteria are explicit.
- Trace signal: each preview links to the policy clause that supports it.
Credit and Financial Decisioning
Pre approval, KYC, risk.
- Typical scope: credit pre approval agents, KYC pre screening, fraud flag triage.
- Review signal: policy conditions and authority boundaries are explicit.
- Risk signal: representative and unsafe scenarios test the proposed boundary.
IT Operations and Incident Response
Severity, blast radius, change management.
- Typical scope: incident response agents, automated remediation, change approval pre checks.
- Review signal: evidence, blast radius, and approval rules are linked.
- Operational signal: scenarios expose remediation outside its proposed authority envelope.
Coding Agents
Governed code and architectural compliance.
- Typical scope: code generation, code review, dependency update pull requests.
- Review signal: architecture and security constraints are explicit.
- Engineering signal: representative changes are tested before Runtime integration.
Background AI Analysts
Governed analysis, versioned assumptions.
- Typical scope: competitive analysis, forecasting, regulatory monitoring, executive briefings.
- Review signal: claims can be linked to their source and assumption.
- Governance signal: invalidated facts are surfaced in test scenarios.
The old way does not scale. Start with one decision boundary.
| Static ontologies | Decision Ontologies (Rippletide) | |
|---|---|---|
| Bootstrap | 6 to 12 months, forward deployed engineers | 10 working days for one scoped Safety Pack, with expert review |
| Source coverage | One canonical schema, manually maintained | Docs, APIs, vector stores, workflow logs, evaluated traces, ingested in parallel |
| Contradictions | Unknown until production fails | Surfaced and routed during structuring (System of Record Integrity) |
| Maintenance | Quarterly review cycle, often skipped | Continuous, outcome conditioned from evaluated traces |
| Validation interface | Modeling DSL, ontology engineer required | Notion style editor in plain English; A or B proposals when uncertain |
| Outcome lift | Unmeasured, not wired to agents | +15 points on average in evaluated production workloads against ground truth |
Frequently asked questions.
Common questions about Automatic Ontologies. Need more detail? Talk to our team
A knowledge graph captures what is known. A semantic layer aligns what is named. A Decision Ontology encodes what is decided, and under what conditions. It is action oriented, outcome conditioned, and designed to support reviewable decision previews today and Runtime control as the product expands.
Source ingestion, candidate ontology generation, contradiction detection, validity window inference, and refinement proposals from evaluated traces. The human stays in the loop for validation in natural language, not a modeling DSL. A first scoped decision model can be reviewed within a 10-working-day Safety Pack.
Documents in any format (PDF, Word, Confluence, Notion, SharePoint, contracts, SOPs, runbooks), APIs and system schemas (CRM, ERP, ticketing, payments, identity), vector stores (existing RAG corpora and embeddings), workflow logs and execution histories, and evaluated agent traces. The breadth is intentional: enterprise knowledge never lives in one place.
A trace without an outcome is a sequence of actions. A trace with an outcome is a learning signal. Rippletide only ingests evaluated traces (actions paired with verified results) because that is what makes them usable for rule derivation. We do not learn from noise. We learn from results.
As Rippletide structures sources into a candidate Decision Ontology, it surfaces contradictions across them: policies that disagree, SOPs that conflict with API constraints, or authority gaps embedded in documented workflows. Each finding stays linked to its source and is routed for human resolution.
No. Rippletide is additive. If you already have an ontology, we ingest it, validate it against your sources, surface contradictions, and extend it with the rules and outcomes you did not have before.
Through a Notion style editor. Your domain experts review proposed entities, relationships, and rules in plain English. When Rippletide is uncertain, it proposes two alternatives (A or B) and asks the expert to choose. Edits in natural language are encoded deterministically. No graph query language. No DSL.
In observed deployment work, outcome-based evaluation rose from approximately 75% to approximately 90% on average. +15 points, measured on production workloads against verified ground-truth outcomes. This is methodology context, not a guaranteed customer result.
A 10-working-day Safety Pack produces a scoped candidate model for one write-action, plus evidence rules, scenarios, decision previews, and a reviewer sign-off package. Broader integration and Runtime control are scoped separately.
The Decision Ontology is yours. Exportable, versioned, auditable. Rippletide is the engine; you own the model. Confirm export modalities with our engineering team during the validation sprint.
The Decision Ontology defines the structure. The Context Graph stores facts within that structure, with temporal validity, provenance, and scope isolation. Together they support offline decision previews today and can support live Runtime control as the product expands.
Related reading.
Automatic Ontologies
Your agents are already deciding. Give them an ontology worth deciding from.
We start with a 10-working-day Safety Pack for one write-action. We connect the relevant sources, build a candidate Decision Ontology, test scenarios, and surface contradictions for reviewer sign-off.
- One scoped Safety Pack in 10 working days
- Evidence-linked scenarios and decision previews
- Contradictions surfaced for human review
- Runtime expansion after the Safety Case is proven