← koiro.me

AI Agent Ontology Architecture RAG

How do you design the environment in which an agent “thinks”? From execution loops and tool wiring through memory layers to ontologies—the backbone of explicit knowledge.

For implementation and UI, the sideseat repo agent-control-plane exposes a Studio (platform-web, Vite+React) where ontology and workflow are edited as graphs. Screenshots, local setup, and panel notes: Agent Control Plane — Studio Web Guide and GitHub.

Part 1

Scaffolding — the agent runtime

“Scaffolding” comes from construction: temporary structure that supports the real build. In agent engineering, scaffolding is the full runtime that lets an LLM actually do work—not the model weights alone.

A raw LLM is a function from prompt to completion. Scaffolding wraps it in a loop, attaches tools and memory, and coordinates other agents when needed.

LangChain, CrewAI, AutoGen, etc. are frameworks that abstract scaffolding—they are not scaffolding itself. You can implement scaffolding without any of them.

Five layers

01
LLM — reasoning engine
Claude · GPT · Gemini — plan, reason, answer
Brain
02
Agent loop
Think → Act → Observe → repeat
Core
03
Tool use
Web search · code · APIs · databases
Interface
04
Memory & orchestrator
Short-term · long-term · RAG  |  multi-agent routing
State
05
Guardrails / eval
Safety filters · output checks · logging · eval loops
Safety

Loop mechanics

The loop is not “call the LLM many times.” Each turn appends an Observation and selects the next Action. Scaffolding owns stop conditions—goal met, max steps, fatal errors.

Tool calls are not executed inside the model. The model emits an intent; your runtime parses, validates, and executes real functions.

In practice you pass JSON Schema (or provider-specific tool specs), parse structured calls, and execute in a sandbox. Protocols like MCP standardize how tools and resources attach to the same scaffolding layer.

Guardrails

The fifth layer is not cosmetic: policy blocks, PII handling, hallucination mitigation, and offline eval all live here. Without logs and metrics you cannot iterate prompts, tools, and models on a consistent ruler.

Part 2

Ontology — the knowledge backbone

In philosophy, ontology is the study of what exists and how kinds relate. In computer science it narrows to a formal knowledge representation—classes, properties, instances, and explicit relations.

For agents, an ontology defines how the system reads the world: what a “person” is, how it relates to an “organization,” which attributes are valid, and what can be inferred.

Besides OWL, teams often use SKOS for lightweight taxonomies or SHACL to validate RDF graphs. These are all trade-offs between expressivity and operating cost under the same “ontology” umbrella.

Building blocks

Ontology OWL 2 / RDF
  • Class Concept taxonomy
    • PersonsubClassOf Thing
    • OrganizationsubClassOf Agent
    • EventsubClassOf Occurrence
  • Property Relations / attributes
    • ObjectPropertyworksFor, partOf
    • DatatypePropertyname, date, value
  • Individual Concrete instances
    • ex:Ahhyunrdf:type Person
    • ex:POSCO_DXrdf:type Organization
  • Axiom Inference / constraints
    • domain / rangeProperty typing
    • equivalentClassClass equivalence

Stack roles

LayerRoleTypical use
RDFTriple facts (subject–predicate–object)Interchange / integration layer
RDFSClass and property hierarchiesSimple taxonomies
OWL 2Rich constraints and reasoningEnterprise knowledge graphs
FOAFVocabulary for people and orgsProfiles / social graphs
SPARQLQuery languageGraph search & inference

Part 3

Intersection — knowledge-grounded agents

Scaffolding defines how the agent acts; ontology defines what world model it assumes. Together they move you beyond ad-hoc tool calls toward domain-grounded reasoning.

Example: energy monitoring—scaffolding runs ingest → anomaly → alert, while ontology states “asset A belongs to process B; normal temperature is X,” facts the agent can query and reason over.

Full OWL 2 everywhere is rare. JSON-LD, property graph DBs, or even disciplined JSON schemas often stand in. What matters is whether relationships are explicit, not the file format.

RAG, broadly, uses unstructured corpora as a knowledge layer. Ontology-first designs differ in inferability—explicit axioms yield new facts, not only similar chunks.

Graph RAG and ontology-aligned embeddings let you assemble context by entity and relation, not only text slices—natural fuel for the memory layer in scaffolding. A common pattern: graph query → grounded triples → LLM summarization for the next loop step.