Super Ontology Architect

Lab Hub | agentlas.cloud | agent_super_ontology_architect

A public research agent for designing adaptive meta-ontologies that can span company, personal, scientific, social, and creative contexts without pretending one fixed schema can rule them all.

Abstract

The naive dream is a perfect universal ontology: one master map that covers any company, any person, any document, any workflow, and any edge case. That dream is tempting and dangerous. Different situations carve the world differently. A legal document, a family memory, a sales pipeline, a lab notebook, a therapy journal, a machine log, and a poem do not share one useful set of entities, relations, time scales, evidence rules, or risks.

This repository researches a stronger alternative: a Super Ontology Architect. It does not store one giant frozen ontology. It operates a meta-ontology system that detects context, chooses domain lenses, aligns concepts across lenses, validates evidence, tracks uncertainty, repairs broken mappings, and exposes only the right slice to the right agent.

Research Question

Can an agent architecture support "every situation" by building, selecting, aligning, and repairing context-specific ontologies instead of relying on one static universal schema?

Thesis

No fixed ontology can be perfect across all possible human, company, scientific, and social situations. The practical answer is a recursive architecture:

universal primitives
  -> context detector
  -> domain lens
  -> local ontology
  -> evidence graph
  -> alignment bridge
  -> action contract
  -> evaluator and repair loop

The Super Ontology is not a single bookcase. It is the rule system that builds the right bookcase for the room, labels the shelves, checks whether the labels still fit, and connects shelves across rooms without mixing up their meanings.

Main Finding

The closest research support comes from combining several traditions:

• top-level ontologies such as BFO, DOLCE, and SUMO for generic categories,
• knowledge graph construction and GraphRAG for extracting structure from data,
• ontology alignment for mapping across incompatible schemas,
• semiotics for sign/context/interpretation,
• ecological psychology for affordances and action possibilities,
• active inference and cybernetics for self-correction under uncertainty,
• formal concept analysis and conceptual spaces for concept discovery,
• category-theoretic ideas for mapping between schemas,
• No Free Lunch results as a warning against one universally best model.

The design conclusion is: universal coverage requires adaptive context management, not a universal flat schema.

Architecture Summary

incoming situation
  -> context boundary detector
  -> observer and purpose model
  -> domain lens selection
  -> local ontology proposal
  -> evidence and provenance binding
  -> cross-lens alignment
  -> action/agent contract
  -> execution feedback
  -> repair, split, merge, deprecate, or rollback

Deliverables

• Architecture Spec: complete layered design for the Super Ontology Architect.
• Cross-Disciplinary Map: what the design borrows from ontology engineering, AI, natural science, cognitive science, semiotics, social science, and systems theory.
• Impossibility Boundary: why "perfect for all situations" cannot mean one fixed schema.
• Failure-Mode Matrix: edge cases that break universal ontology attempts.
• Evaluation Plan: how to test generality without fooling ourselves.
• Operating Protocol: the actual runtime loop for unknown situations.
• Generality Benchmark: test suite for personal, company, scientific, social, creative, and mixed contexts.
• Fixture Guide: seed JSONL benchmark cases for checking broad-context behavior.
• Trace Scoring Guide: executable run-trace contract and scoring harness.
• World Coverage Guide: coverage matrix for checking broader personal, company, science, social, regulated, physical, and multimodal contexts.
• Open-World Coverage Contract: fixture gate for new world, task, modality, fault, authority, and write-surface combinations that were not represented by earlier examples.
• Consensus Coordination Contract: multi-agent and cross-runtime coordination gate for cases where agreement, debate, majority vote, model judging, replica sync, or route sync could amplify a wrong claim.
• Observability Telemetry Contract: trace/span/correlation/audit gate for graph, memory, tool, public, route, release, repair, rollback, and emergency-stop events.
• Objective Proxy Validity Contract: construct-validity gate that blocks approval rate, benchmark score, test pass rate, open rate, edge count, or cost metrics from becoming optimization authority without countermetrics and gaming probes.
• Stakeholder Preference Governance Contract: preference-legitimacy gate that blocks owner approval, majority vote, behavior signals, or role power from becoming write authority without stakeholder maps, authority scope, aggregation rules, dissent, appeal, and rollback.
• Normative Authority Drift Contract: policy/law/contract/license/consent validity gate that blocks stale policies, wrong jurisdictions, draft contracts, expired exceptions, translations, summaries, or license gaps from becoming write authority without primary source refs, effective dates, scope, precedence, review owner, and rollback.
• Side-Effect Containment Contract: execution-safety gate that blocks sends, payments, deletes, releases, cloud permission changes, database writes, training updates, scheduled jobs, route sync, and physical actions from committing without dry-run, idempotency, approval, blast-radius, compensation, receipt, audit, and rollback evidence.
• Source Lineage Version Contract: source-authority gate that blocks drafts, exported PDFs, summaries, translations, redacted copies, stale connector caches, spreadsheet tabs, chunks, embeddings, and Memory Curator notes from becoming graph, memory, public, training, tool, or route authority without source URI, checksum, version, derivation chain, owner, span, audit, and rollback evidence.
• Entity Identity Resolution Contract: identity-authority gate that blocks names, aliases, email domains, phone numbers, fuzzy matches, embedding clusters, reused ids, stale aliases, external URIs, redacted ids, and LLM-generated canonical labels from becoming canonical graph nodes, memory identities, public artifacts, training examples, personalization rules, tool authority, or route authority without entity id, source-system namespace, source span, disambiguating attributes, negative evidence, temporal validity, owner review, audit, and rollback.
• Temporal State Transition Contract: time/state-authority gate that blocks current snapshots, materialized views, spreadsheet row order, local timestamps, LLM summaries, late events, future-effective policies, expired memories, deleted nodes, partial failures, recurring jobs, stale caches, and graph edges without temporal bounds from becoming graph, memory, public, training, tool, route, scheduled, permission, financial, release, or customer-output authority without valid time, transaction time, event id, event order, pre/post state, transition guard, replay log, projection version, audit, and rollback.
• Capability Delegation Authority Contract: actor/capability-authority gate that blocks roles, groups, OAuth scopes, API keys, service accounts, session cookies, tool schemas, cached policy decisions, broad approvals, and child-agent tokens from becoming graph, memory, public, training, tool, route, scheduled, permission, financial, release, customer-output, or physical authority without actor, principal, task, operation, resource, scope, purpose, delegation chain, caveats, policy decision, revocation check, audit, rollback, and post-action verification.
• Privacy Confidentiality Boundary Contract: privacy/confidentiality gate that blocks PII, secrets, HR notes, legal privilege, personal diary context, customer decks, connector caches, screenshots, embeddings, and inferred sensitive attributes from becoming graph, memory, public, training, tool, route, customer-output, personalization, retrieval, or analytics authority without classification, subject category, owner/controller, purpose, audience, legal or confidentiality basis, minimization, redaction, retention, transfer, public/training flags, access decision, audit, breach owner, and rollback.
• Strategic Incentive Compatibility Contract: incentive/mechanism gate that blocks self-reports, KPIs, commissions, vendor claims, customer ratings, agent votes, benchmark scores, compliance attestations, approvals, cost savings, retention metrics, and family pressure from becoming graph, memory, public, training, tool, route, release, financial, hiring, policy, customer-output, analytics, evaluation, or personalization authority without principal/agent roles, private-information inventory, payoff model, conflict disclosure, strategic-behavior hypothesis, holdout or audit evidence, independent verification, mechanism constraints, review, appeal, audit, rollback, and residual incentive risk.
• Reflexive Feedback Stability Contract: closed-loop stability gate that blocks post-intervention observations, recommendation effects, generated artifacts, dashboard movement, repeated retrieval, agent self-scores, market responses, and user adaptation from becoming graph, memory, public, training, tool, route, release, financial, hiring, policy, customer-output, analytics, evaluation, physical-action, or personalization authority without intervention id, baseline, feedback path, lag window, holdout or counterfactual, real-world anchor, stability margin, damping, saturation bound, monitoring, stop condition, rollback, owner review, and residual feedback risk.
• Meta-Agent Packaging Rehearsal: executable generated-agent scenarios that turn mixed company or personal source bundles into candidate packages, bounded context packs, Memory Curator tickets, candidate ontology edges, and memory-edge links while blocking private data, stale sources, generated outputs, and post-intervention feedback from becoming write authority.
• Task Coverage Contract: coverage matrix for checking the kind of work requested before graph slices, memory handoffs, tool bindings, or runtime actions are allowed.
• Contextual Flow Contract: information-flow gate for checking sender, recipient, subject, attribute, purpose, authority, retention, and transmission principle before information crosses personal, company, customer, public, regulated, agent, memory, tool, or output boundaries.
• Causal Impact Contract: counterfactual and blast-radius gate for checking whether a relation may become a write, publish, execute, physical, or training intervention.
• Assurance Case Contract: evidence-linked argument graph for claims about coverage, memory safety, action safety, promotion readiness, sync integrity, and rejected perfection overclaims.
• Knowledge Homeostasis Contract: vital-sign, error-budget, quarantine, repair, rollback, and retirement gate for stale, contradictory, drifting, desynced, or privacy-incident knowledge.
• Adversarial Provenance Contract: zero-trust source gate for prompt injection, data poisoning, spoofed citations, forged provenance, hidden OCR instructions, memory poisoning, tool-output tampering, stale trusted-source replay, and supply-chain tampering before any retrieval, memory, tool, or public-runtime promotion.
• Epistemic Calibration Contract: uncertainty, abstention, selective-answer, retrieval-retry, human-review, and shadow-replay gate for cases where evidence is missing, contested, underspecified, out-of-distribution, uncalibrated, or unknowable for now.
• Semantic Alignment Contract: schema, glossary, ontology, entity, and term-mapping gate for cases where the same label may mean different things or different labels may mean the same thing.
• Resilience Control Contract: MAPE-K/STPA-style control loop for degrading to watch, read-only, quarantine, rollback, or emergency-stop modes when feedback, validators, tools, sync, or memory signals become unhealthy.
• Invariant Verification Contract: runtime-verification and temporal-logic gate for checking whether event sequences such as memory tickets, graph writes, tool calls, public exports, route sync, release seeds, rollback, and emergency stop are allowed at all.
• Kernel Execution Guide: executable seed kernel that turns fixtures into run traces.
• Repair Kernel Guide: turns failed traces into candidate repair events.
• Repair Promotion Guide: blocks or quarantines repair candidates before ontology mutation.
• Source Intake Guide: classifies raw file modalities before ontology generation.
• Evidence Packet Guide: converts source intake records into provenance-bound candidate evidence before ontology writes.
• Belief Ledger Guide: tracks supported, contested, stale, refuted, and blocked claims before promotion.
• Knowledge Capsule Guide: exposes only a permissioned task slice to downstream agents.
• Affordance Action Binding Guide: binds capsules to allowed, review-gated, or blocked tool actions.
• Agentlas Memory Curator Integration: defines the candidate contract between this research repo, PM Soul, Memory Curator, Meta Agent, Hephaestus public core, Web, Desktop/terminal, and AppBridge.
• Memory Curator Bridge Contract: forces Super Ontology memory handoffs through redacted Memory Tickets, idempotency keys, scope labels, trust labels, conflict policy, and rollback.
• Promotion Readiness Gate: checks whether a candidate has enough proof to move from research into Agentlas runtime surfaces.
• Promotion Evidence Collection: collects current local proof for readiness gates without hardcoding local paths into the public repo.
• Promotion Replay Drills: rehearses shadow, canary, sync-review, block, and rollback behavior before any Agentlas runtime surface is modified.
• Shadow/Canary Replay Corpus: tests unknown company, personal, regulated, creative, multimodal, social, scientific, tool-authority, and Agentlas runtime situations before any official ontology write.
• Recent Research Anchors: source-backed research anchors for KG construction, open-world agent evaluation, context engineering, ontology-guided RAG, temporal GraphRAG, and least-privilege tool agents.
• AX KG Integration: how this repo sits above the AX Knowledge Graph Curator.
• Pseudocode: routing, lens synthesis, alignment, and repair algorithms.
• Simple Korean Explanation: plain-language version.
• Research Log: dated research decisions.

Agent Contract

• Purpose: design and govern adaptive meta-ontologies across personal, enterprise, scientific, social, and creative settings.
• Inputs: situation description, data sources, user goal, actor roles, evidence types, risk tier, existing ontologies, tool affordances, and prior failures.
• Outputs: context model, selected domain lens, local ontology, alignment map, evidence contract, action contract, contextual flow contract, causal impact contract, assurance case, knowledge homeostasis decision, epistemic calibration decision, semantic alignment candidate, resilience control mode, invariant verification decision, objective proxy validity decision, stakeholder preference governance decision, normative authority drift decision, capability delegation authority decision, execution policy, evaluation plan, and repair decision.
• Tools: document parsing, KG construction, ontology alignment, schema validation, provenance, retrieval diagnostics, context classifiers, human review queues, and rollback logs.
• Memory: stores meta-rules and validated lens patterns; raw private data stays in the owning workspace.
• Permissions: can propose lenses and mappings automatically; cannot promote high-risk truth without validation.
• Evaluation: task success, evidence faithfulness, context fit, alignment precision, repair quality, safety boundaries, and graceful failure.
• Known failure modes: context collapse, ontology bloat, false universalism, over-alignment, meaning drift, hidden value conflicts, privacy leakage, and self-repair loops that overfit one failure, proxy objective capture, preference legitimacy collapse, and normative authority drift.

Repository Map

• agent.md: usable agent contract.
• AGENTS.md: Codex operating rules for this repo.
• CLAUDE.md: Claude Code guide for this repo.
• memory.md: public agent memory.
• docs/: architecture, research, matrix, evaluation, and explanations.
• agents/: role hierarchy for implementation teams.
• skills/: reusable research and audit skills.
• fixtures/: synthetic benchmark cases for generality testing.
• scripts/score_fixture_traces.mjs: checks whether run traces satisfy fixture expectations.
• scripts/check_world_coverage.mjs: checks whether the seed suite covers the required world categories.
• scripts/check_task_coverage.mjs: checks whether the seed suite covers required task families, affordances, evidence modes, clarify/block cases, and rollback requirements.
• scripts/check_contextual_flows.mjs: checks cross-context information flow, contextual privacy, role/authority, redaction, retention, and public/private boundary cases.
• scripts/check_causal_impact.mjs: checks causal claim type, intervention target, counterfactuals, adverse outcomes, observability, reversibility, blast radius, and rollback before state-changing actions.
• scripts/check_knowledge_homeostasis.mjs: checks knowledge health signals, error budgets, runtime write blocks, Memory Curator policies, public export limits, repair, rollback, and retirement decisions.
• scripts/check_adversarial_provenance.mjs: checks hostile-source, spoofed-provenance, poisoned-memory, tampered-tool, hidden-OCR, stale-replay, and supply-chain cases before arbitrary material can become retrieval context, durable memory, tool authority, or public seed.
• scripts/check_epistemic_calibration.mjs: checks that low-confidence, contested, underspecified, out-of-distribution, stale, noisy, or uncalibrated claims ask, retrieve more, cite only, review, abstain, block, or shadow replay instead of becoming runtime writes.
• scripts/check_assurance_cases.mjs: verifies that broad coverage, safety, memory, action, promotion, red-team, and sync claims have explicit evidence, validators, residual risk, and rollback.
• scripts/simulate_super_ontology_kernel.mjs: emits candidate run traces from fixture cases and kernel policy.
• scripts/generate_repair_tickets.mjs: emits candidate repair events from failed traces.
• scripts/decide_repair_promotions.mjs: converts repair events into promotion, quarantine, or review decisions.
• scripts/check_source_intake.mjs: verifies raw source modality, parser, privacy, and join-policy coverage.
• scripts/generate_evidence_packets.mjs: emits provenance-bound candidate evidence from source intake records.
• scripts/check_evidence_packets.mjs: verifies evidence packet coverage and ontology write policies.
• scripts/check_belief_ledger.mjs: verifies temporal, conflicting, stale, refuted, and blocked belief handling.
• scripts/check_knowledge_capsules.mjs: verifies safe graph slices for downstream agents.
• scripts/check_affordance_bindings.mjs: verifies tool/action permissions and argument provenance.
• scripts/check_agentlas_integration_contracts.mjs: verifies candidate integration boundaries for Agentlas memory and sync surfaces.
• scripts/check_semantic_alignment.mjs: verifies schema, glossary, ontology, entity, relation, and term-alignment candidates before they can become graph or memory changes.
• scripts/check_resilience_control.mjs: verifies degraded-mode, unsafe-control-action, feedback, rollback, and emergency-stop behavior before runtime promotion.
• scripts/check_invariant_verification.mjs: verifies temporal ordering, authority, provenance, consent, idempotency, rollback, audit, and emergency-stop invariants before runtime writes.
• scripts/check_consensus_coordination.mjs: verifies multi-agent agreement, majority votes, debate, model judges, distributed replicas, and cross-runtime sync cannot become write authority.
• scripts/check_observability_telemetry.mjs: verifies trace/span/correlation/audit telemetry before state-changing runtime events can be considered.
• scripts/check_objective_proxy_validity.mjs: verifies proxy metrics, Goodhart/Campbell failure modes, stakeholder scope, countermetrics, and metric-redesign or rollback plans before optimization.
• scripts/check_stakeholder_preference_governance.mjs: verifies stakeholder roles, preference signals, conflict types, aggregation rules, dissent capture, appeal paths, consent, veto, review, and rollback before preference-driven writes.
• scripts/check_normative_authority_drift.mjs: verifies policy, law, contract, license, consent, retention, transfer, exception, jurisdiction, effective-date, precedence, review, and rollback coverage before authority-like sources can influence writes.
• scripts/check_side_effect_containment.mjs: verifies dry-run, idempotency, approval, transaction, compensation, cancellation, blast-radius, external receipt, audit, and rollback evidence before side-effecting actions can execute.
• scripts/check_entity_identity_resolution.mjs: verifies entity identity evidence, namespace, alias, merge/split, tombstone, temporal, privacy, conflict, and rollback coverage before canonical nodes, sameAs-like edges, memory identities, public exports, personalization, training examples, tool authority, or route authority can be promoted.
• scripts/check_capability_delegation_authority.mjs: verifies actor identity, principal type, delegation chain, scope, purpose, caveats, policy decision, revocation, audit, rollback, and post-action verification before role, token, service-account, approval, or tool-schema evidence can influence authority-bearing use.
• scripts/check_strategic_incentive_compatibility.mjs: verifies principal/agent roles, incentive signals, private information, conflict states, manipulation vectors, mechanism evidence, collusion checks, holdouts, independent verification, audit, and rollback before incentive- bearing signals can influence authority.
• scripts/check_reflexive_feedback_stability.mjs: verifies intervention ids, baselines, feedback paths, lag windows, holdouts, real-world anchors, stability budgets, damping/rate limits, saturation, externalities, stop conditions, monitoring, and rollback before loop-affected signals can influence authority.
• scripts/check_promotion_readiness.mjs: verifies missing proof before public-core, Web, Desktop/terminal, or AppBridge promotion.
• scripts/collect_promotion_evidence.mjs: gathers sanitized local evidence for promotion readiness.
• scripts/check_promotion_evidence.mjs: verifies collected promotion evidence rows.
• scripts/check_promotion_replays.mjs: verifies shadow, canary, and rollback replay drills before promotion.
• .agentlas/: public schema examples.