Ontology-Driven Agent Control: Building Controllable AI Execution with Harness Engineering

The article addresses the core challenge of enterprise AI Agent deployment: Agents demonstrate impressive autonomy in demos but fail in real business contexts due to imprecise terminology, reasoning drift, and misalignment with enterprise rules — essentially "confidently doing the wrong thing." The root cause is not model capability but the lack of a semantic structure that encodes business boundaries and decision rules.

Redefining "Safe and Controllable" as a Multi-Dimensional Engineering Problem

The author breaks down controllable execution into six independent yet related dimensions: permission/isolation (RBAC/ABAC, API gateways), behavioral constraints (Prompt constraints, tool whitelists, ontology modeling), audit/traceability (operation logs, decision-chain tracing), exception handling (circuit breakers, human-in-the-loop, idempotency), result validation (rule engines, formal verification, ontology constraint checks), and regulatory alignment (compliance knowledge bases, approval flows). The ontology-driven approach primarily targets behavioral constraints and result validation while contributing to auditability.

Architecture Constraints: From External Fences to Internal Skeleton

Traditional engineering constraints (Prompt rules, allow-lists, workflow orchestration) work for simple scenarios but face three structural issues at scale: rule maintenance cost explodes, natural-language rules are ambiguously interpreted by models, and semantic relationships between rules and business objects remain implicit. Ontology changes this by defining the Agent's behavior space upfront — constraints become an internal skeleton rather than external fences. Business rules are explicitly modeled as queryable, verifiable structures; tools are managed at the ontology layer (what tools exist, how they trigger, execution flows). Validation occurs after Agent output but before operation execution: the system compares the Agent's intent against the ontology, rejects violations deterministically, and provides traceable rule-node and relationship-path evidence.

Context Engineering: From Memory Patching to Memory Reconstruction

Agents lose context in long tasks because information is stacked as linear text. Ontology represents enterprise data, processes, and relationships as an explicit, queryable semantic network. This yields three improvements: (1) Precise retrieval replaces full-context injection — the cognitive engine extracts a task-relevant semantic subgraph and injects only that into the reasoning context, eliminating overflow and noise. (2) Consistency assurance — a single managed semantic network handles expired, conflicting, or redundant knowledge, so Agents always reason on the latest consistent view. (3) Cross-task reuse — the same semantic structure serves multiple Agents across scenarios, acting as a persistent "business map." The ontology also bridges symbolic reasoning (deterministic where structure exists) and LLM reasoning (flexible where structure is absent), with LLM conclusions explicitly tagged with confidence status.

Feedback Loop: From Subjective Evaluation to Traceable Verification

Current model-based evaluators are easily fooled by superficially plausible outputs. Ontology enables objective verification: many business judgments (quota limits, preconditions, process logic) are rule-based and can be directly validated. Hard constraints are checked by ontology; soft constraints (business conventions, anomaly motives, "major change" definitions) combine LLM evaluation or human review. The loop also evolves the ontology: Agent execution generates real business data that feeds back to identify uncovered concepts, frequent error paths, and needed corrections — a continuous evolution distinct from static knowledge graphs. Explainability is inherent: every verification conclusion traces to specific rule nodes, satisfying regulatory demands for provable compliance in finance, industry, and rail.

Knora: From Technical Control to Business Control

1. Constraints from Business Structure, Not Engineering Assembly

Traditional Harness solutions stabilize Agents within engineering boundaries (human-written rules, Prompt-maintained compliance). Ontology-driven control lets constraints derive directly from business structure: enterprise objects, relations, and rules are unified in an ontology; Agents must enter this semantic layer to reason and decide, operating on a predefined "business map." This shifts Agents from tool executors to semantic participants, enables constraint reuse across scenarios, and keeps business rules stable across model iterations.

2. Knora System Architecture

Ontology Layer (Knowledge Base): Uses a Labeled Property Graph (LPG) to store the ontology schema. Five core meta-concepts: Entity (business objects: work orders, equipment, personnel), Relation (semantic links), Event (meaningful state changes), Action (executable operations with trigger conditions and parameter constraints), Logic (DAG-orchestrated execution flows). Action and Logic transform ontology from static description into executable business specifications that directly drive Agent tool calls and orchestration. Tools are defined at the ontology layer, not the Agent layer.

Cognitive Engine Layer (Translation & Arbitration): Bridges ontology and Agent. Before execution, it extracts domain knowledge (entity relations, business rules, available tools) from the ontology and injects it into the Agent's reasoning context. After execution, it validates the Agent's output against ontology constraints; violations trigger re-reasoning.

Agent Execution Layer: Pure executor — receives tasks, calls tools, produces results. Tool availability, usage, and boundaries are dictated by the ontology layer via the cognitive engine.

Data Flow: User task → Cognitive engine extracts relevant ontology knowledge → Agent reasons/executes → Results return to cognitive engine for ontology validation → Output only after passing.

3. Manufacturing Case Study: Work Order Quantity Change

User intent: Change work order WO-2026-0312 planned quantity from 500 to 800. Cognitive engine queries LPG graph: node WO-2026-0312 (type WorkOrder, state "issued/not started"), attribute change magnitude 60% exceeding the 20% approval threshold defined in ontology. Action rule: over-threshold change requires requiresApproval = true. Relation chain:

WorkOrderChange → approvedBy → [BOMEngineer, ProductionManager]

. Validation fails due to missing approvedBy relation. System blocks direct write, generates structured error report citing violated rule node and relation path, auto-creates approval task routed to designated approvers, logs intent as "pending approval." After approval, approvedBy relation is added, re-validation passes, write executes.

4. Auto-Modeling: Layered Processing with Human-in-the-Loop

Cold-start cost is addressed via layered, confidence-driven automation: structured, regular tasks (field-to-ontology attribute mapping, auto-generating data-governance DAGs from ontology metadata) are automated; semantic judgment and concept boundary tasks remain human-assisted. Each auto-generated result receives a confidence score: high → execute; medium → recommend human confirmation; low → review queue. Human interventions are precise, targeting only ambiguous parts. Corrections feed back to improve future automation; industry templates and domain samples gradually reduce human involvement.

5. Production Deployments

Energy/Transport (Railway): Comprehensive inspection report generation Agent auto-builds indicator systems and generates reports. Reduced effort from 30 people / 7 days to 3 people reviewing data + 30 minutes Agent generation — over 70x efficiency gain. Deployed as "digital employees" across safety hazard identification, maintenance planning, emergency plan generation, and emergency resource scheduling.

Electronics Manufacturing: Quality traceability and defect analysis scenarios transformed experience-dependent manual processes into precise knowledge-driven automated digital workflows.

Conclusion

Enterprise AI adoption is diverging: one path piles tools, Prompts, and integrations — Agents run but outcomes are opaque. The other builds business structure first, letting Agents act on a clear semantic map where boundaries, rules, and decision rationale are explicit. Short-term cost difference is small; long-term divergence appears at every regulatory explanation, cross-system semantic clash, and critical "confident mistake" moment. The ultimate competitive moat is not purchased tools but structured business cognition: Agents and models will be replaced, but ontology-embedded business knowledge persists and self-evolves with every execution and iteration.