Technology

Agentic Ontology

The bounded world model behind every KUON agent. A declared, typed, parser-enforced runtime where every capability is a command and every state change is reversible.

The Agentic Ontology is the bounded world model and command surface that every KUON agent reads, writes, and operates against. It is not a diagram of objects. It is the runtime that turns intent into controlled, auditable, reversible action.

Where most agent platforms treat ontology as a data layer — a graph of types and relationships behind a query language — the Agentic Ontology treats ontology as an operational one. Commands. State. Audit. Rollback. Approval. The grammar of agency, applied uniformly to every object in the world.

Ontology Overview

The bounded world model

A declared, typed set of objects every agent can see and act on. Memory is history. The world model is the present — parser-enforced, replayable, scoped per agent, refusing anything the agent cannot name.

  • Sessions, jobs, runs, tools, channels, configs, skills.
  • Relationships, lineage, and provenance, all typed and queryable.
  • Read-only snapshots for inspection; scoped writes for mutations.
Ontology Language

The grammar of agency

A small set of verbs every command supports. Same verbs, every object. The language refuses to skip a step — and that refusal is the point.

  • list, describe, plan, dry-run, validate.
  • apply, status, logs, diff, rollback.
  • Schema-validated flags. Structured output. Predictable errors.
Ontology Engine

The runtime that makes the language do work

Propose, authorize, audit, restore. The engine turns a command from a string into a controlled mutation — with a verifiable trail and a one-verb rollback when something goes wrong.

  • Approval gates for anything beyond read scope.
  • Append-only audit log keyed to actor, intent, command, and result.
  • State snapshots before every apply, with diff and rollback paths.
Ontology Toolchain

What you actually build with it

The Agentic Ontology is not a vision deck. The toolchain is the live runtime: every product KUON ships is the ontology, made concrete against a real workflow.

  • RapidClaw — voice co-pilot for EVM Advisor.
  • Kurosawa — production dashboard for AI workflows.
  • Sheepdog — launch discipline for sub-agents.
  • Config Sentinel — safe config.apply for OpenClaw.

What lives in the ontology.

The world model is finite and declared. Every object the agent can read or write is named here, with a typed contract and an action surface. Nothing implicit. Nothing hidden.

sessionA bounded, scoped conversation. Read scope, write scope, parent, status, lifecycle.
jobA unit of work submitted to the runtime. Inputs, dependencies, deadline, owner.
runAn execution attempt of a job. Logs, exit, duration, output, audit trail.
toolAn executable capability the runtime can invoke. Verb set, schema, sandbox, rate limit.
channelThe medium an agent speaks through. Telegram, voice, dashboard, CLI, web.
configA typed, versioned setting the runtime reads. Validate-before-apply; rollback one verb away.
skillA named, composable procedure an agent can request. Preconditions, effects, owner.
skillsetA bundle of skills scoped to an agent or workspace. What it can read, what it can do.
workspaceThe boundary an agent operates inside. Memory, secrets, agents, channels, configs.
Example • RapidClaw v0.7 on BOOMERANG

The same ontology, running live.

A RapidClaw voice session is a sequence of ontology commands. The voice host reads, resolves, renders, and closes. The agent cannot invent a number because the ontology does not give it a command for inventing numbers — only for reading, resolving, and rendering the source of record.

  • session.create opens the bound voice session scoped to the named project.
  • evm.status reads CPI and SPI from the Empower source of record — bottom line first.
  • evm.drivers resolves the lowest-level WBS elements driving the variance.
  • chart.render writes the native Empower chart to the watch pane.
  • session.close releases the bound context. Every step logged; every state change reversible.
$ session.create --project BOOMERANG
  session_id: sess_2bc14f8a
  scope:       BOOMERANG
  bound_at:    2026-06-28T21:56:56-07:00
$ evm.status   --project BOOMERANG --source empower
  cpi: 0.861   spi: 0.909
  verdict: cost-inefficient, behind schedule
$ evm.drivers --project BOOMERANG --metric cost --depth leaf
  1. Load Propellant     cpi 0.689
  2. Develop Code        cpi 0.821
$ chart.render --chart spi_cpi --project BOOMERANG
  → wrote chart to watch pane (native Empower)
  source_of_record: empower://BOOMERANG/wbs
$ session.close --session sess_2bc14f8a
  state: clean   rollback: not needed
Each step is a real command against the bounded world model. Nothing is invented; everything is logged; rollback is one verb away.