Open Ontology logoOpen Ontology
Enterprise agent runtime - research preview

The programmable
operations layer
for enterprise agents.

Open Ontology lets agents understand the business, act through governed workflows, persist state, explain what happened, and improve over time.

Model a slice of your operations: entities, relationships, rules, workflows, tasks, and historical facts. Agents query current and historical state, use deterministic business rules alongside model reasoning, and leave every action in an auditable triple store.

Open Dashboard
View DocsGitHub
localhost:3000/databases/demo-hr

Models are powerful. Operations are messy.

Enterprise work is full of state: customers, vendors, employees, cases, approvals, policies, deadlines, exceptions, handoffs, and systems of record. An agent needs that context before it can make a useful decision.

Without an operational substrate, every deployment becomes a bespoke integration project. The model has to infer the business from documents, chat history, tickets, and tool responses. Rules stay implicit. Memory is fragmented. Governance lives outside the agent loop.

Open Ontology turns the workflow itself into infrastructure. The business context is explicit and queryable. Rules are deterministic. Actions are governed. State persists across interactions. Corrections become new facts instead of silent mutations.

Nine primitives for operational AI.

Agents get durable business context from these building blocks, each defined with a define-* form in the Lisp DSL.

Entities

Things with stable identity and typed attributes

Customers, employees, vendors, cases, policies, assets: the nouns agents must not confuse.

Relationships

Typed, temporal connections between entities

Who owns the case, which contract applies, what changed, and when it was true.

Queries

Saved Datalog patterns for deterministic joins and reasoning

"All active vendors with expired certificates" becomes a reusable business question.

Mutations

State-changing operations with typed inputs

Agents change state through explicit operations, not ad hoc writes to hidden tables.

Actions

Governed tool calls with typed boundaries

Check a compliance API, send a notification, generate a report, record the result.

Processes

Workflow DAGs that orchestrate multi-step operations

Onboarding: create case, collect docs, verify, approve, escalate, and close.

Constraints

Declarative rules that detect violations continuously

"Every active vendor must have a valid certificate." Deterministic guardrails for agents.

Views

Declarative UI composition binding queries to components

The same operational graph powers work queues, inspection, triage, and review.

Workspaces

Persona-oriented dashboards that organize views

"Onboarding Coordinator" sees the queues, decisions, and exceptions they own.

From workflow to agent runtime

A vendor certification process with memory, rules, tasks, and auditability.

1Define the business context

Entities are things with identity. A Vendor has a name and status. A Certificate has a type and expiration date. A relationship records which certificate governs which vendor.

2Make the rule explicit

Constraints are Datalog queries that define what shouldn't exist. If this query returns results, you have violations: active vendors with expired certificates.

3Let agents work through the loop

Deploy the ontology. The runtime evaluates the rule continuously. When a certificate expires, a violation surfaces, a task is routed, and an agent can gather context, request renewal, call approved tools, and record what changed.

Rule fires -> Violation created -> Task routed
       ^                                  |
       |____ Certificate renewed _________|

The layer beneath reliable agents

Model vendors compete above it. Business operations become stable underneath it.

Database

Time-traveling triple store

[entity, attribute, value]

Every fact is timestamped and queryable. Agent actions, corrections, approvals, and business state accumulate as durable memory instead of disappearing into logs.

Language

Business context as code

(define-entity Vendor ...)

Entities, relationships, workflows, tasks, rules, views, and tools live in source. The operational model can be reviewed, versioned, deployed, and reused.

Compiler

Source to IR to runtime payloads

lisp -> IR -> runtime payloads

Canonical source lowers into deployable metadata for entities, relationships, rules, processes, actions, views, and agent tool boundaries.

Runtime

Governed agent operations

query -> act -> assert -> explain

Agents query context, invoke typed actions, execute workflow steps, and write new facts through explicit APIs. The layer works alongside OpenAI, Anthropic, Bedrock, internal models, and whatever comes next.

Application

Web, API, CLI, and MCP

model -> connect -> deploy -> measure

Encode a workflow once, connect it to systems of record, deploy agents against it, inspect failures, correct the model, and reuse the pattern across teams.

Agent work becomes observable state

Workflows run through memory, rules, actions, approvals, and feedback.

Business facts -> Rules -> Agent actions -> New facts
      ^                                      |
      |_________ Inspect, correct, replay ___|

Memory

Every agent action writes facts: what it knew, what it changed, which source it used, who approved it, and when it happened.

Governance

Rules, workflow states, tool boundaries, and approvals are explicit. Agents operate inside the business process instead of around it.

Correction

Failures become inspectable state. Corrections become new facts. The next run has better context without erasing the history that explains why.

Model, deploy, observe, correct

Define the Operational Graph

Entities, relationships, and seed facts in a Lisp DSL. The compiler turns source into runtime metadata for the triple store.

Give Agents Deterministic Questions

Datalog queries with pattern matching. Shared variables create implicit joins. This finds all active vendors with expired certificates.

Deploy a Governed Runtime

Bundle the ontology as a versioned package. Agents can query, assert, retract, explain, and act through the deployed model.

Start with one agent workflow

Encode the business context, rules, tools, approvals, and feedback loop it needs.

Open Dashboard
View Docs