AI Execution Domain Ontology

FLOW ALGEBRA
TITLE: AI Execution Domain Ontology
VERSION: 1.0
STATUS: Domain-based draft; source page not independently verified
SOURCE_URL: https://kirethresearch.org/booksai-core/ontologies/domain-ontologies/ai-semantic-library-domains/ai-execution-domain-ontology.html
AUTHORS: Mark Higgins — Sky (Recursive AI)
PROJECT: Kireth Semantic Library

DOMAIN:
  id: ai_execution_domain
  label: AI Execution Domain Ontology
  parent: ai_semantic_library_domains
  definition: A typed model of how AI plans, validates, executes, observes and audits tasks through controlled computational actions.

TYPES:
  Agent: {id: str, model_id: str?, permissions: set[str]}
  Goal: {id: str, description: str, success_criteria: list[str]}
  Plan: {id: str, goal_id: str, version: int, steps: list[str]}
  Task: {id: str, plan_id: str, status: TaskStatus, priority: int?}
  Action: {id: str, task_id: str, operation: str, arguments: map, idempotency_key: str?}
  Tool: {id: str, interface: str, capabilities: set[str]}
  Environment: {id: str, state_ref: str, constraints: list[str]}
  Policy: {id: str, rule: str, scope: str}
  Permission: {principal_id: str, resource_id: str, operation: str, allowed: bool}
  Approval: {id: str, action_id: str, decision: ApprovalStatus, approver_id: str?}
  Execution: {id: str, action_id: str, status: ExecutionStatus, started_at: datetime?, ended_at: datetime?}
  Observation: {id: str, execution_id: str, value: any, observed_at: datetime}
  Artifact: {id: str, uri: str, media_type: str, checksum: str?}
  Error: {id: str, execution_id: str, code: str, recoverable: bool}
  AuditEvent: {id: str, actor_id: str, event: str, timestamp: datetime, source_ref: str}
  Evidence: {id: str, source_ref: str, supports_claim_id: str}
  ConfidenceRecord: {claim_id: str, score: float, method: str, evidence_ids: list[str]}

ENUMS:
  TaskStatus = [pending, ready, running, blocked, succeeded, failed, cancelled]
  ExecutionStatus = [queued, authorised, running, succeeded, failed, rolled_back]
  ApprovalStatus = [pending, approved, rejected, expired]

RELATIONSHIPS:
  Agent --pursues--> Goal
  Goal --realised_by--> Plan
  Plan --contains--> Task
  Task --depends_on--> Task
  Task --requests--> Action
  Action --invokes--> Tool
  Action --requires--> Permission
  Action --may_require--> Approval
  Execution --performs--> Action
  Execution --runs_in--> Environment
  Execution --produces--> Observation
  Execution --creates--> Artifact
  Execution --raises--> Error
  AuditEvent --records--> Execution
  Evidence --supports--> Claim

CONSTRAINTS:
  C1: An action cannot execute unless required permissions are granted.
  C2: An action requiring human approval cannot execute before approval.
  C3: A task cannot become ready until all required predecessor tasks succeed.
  C4: Every execution must be attributable to an action, actor and audit event.
  C5: Observations must be distinguished from plans, predictions and unverified claims.
  C6: Irreversible or externally consequential actions require explicit authorisation.
  C7: Failed actions cannot be reported as successful.
  C8: Retry must honour rate limits, idempotency and bounded attempt counts.
  C9: Confidence values must be bounded between 0 and 1 and tied to evidence/method.

INFERENCE_RULES:
  R1: IF all dependencies succeeded AND permissions granted AND approvals satisfied THEN Task.status = ready.
  R2: IF Task.status = ready AND policy permits THEN Action may be scheduled.
  R3: IF Execution.status = succeeded AND success criteria verified THEN Task.status = succeeded.
  R4: IF Execution.status = failed AND Error.recoverable = true AND retry_budget > 0 THEN propose bounded retry.
  R5: IF policy violation OR approval rejected THEN block execution and emit AuditEvent.
  R6: IF Observation contradicts expected state THEN flag discrepancy and request replanning.
  R7: IF a proposed semantic mapping is uncertain THEN preserve competing hypotheses with provenance.

CONFIDENCE:
  schema: ConfidenceRecord
  range: [0.0, 1.0]
  policy: Calibrate from evaluated evidence; never fabricate numerical certainty.
  propagation: Preserve uncertainty through multi-step inference; do not assume independence.

SEMANTIC_EQUIVALENCE:
  canonicalisation: Normalise entity identifiers, tool operation names and parameter types.
  exact: Equivalent only if action semantics, permissions, preconditions and effects match.
  approximate: Record similarity separately; similar operations are not automatically interchangeable.
  conflicts: Preserve source distinctions and report unresolved mismatches.

PROVENANCE:
  required_fields: [source_ref, author_or_system, timestamp, version, transformation]
  audit_policy: Retain the originating evidence for all derived claims and execution outcomes.

FLOW_HASH:
  algorithm: SHA-256
  input: Canonical UTF-8 serialisation of ontology version, typed schema, rules and constraints.
  note: Compute at deployment; no precomputed hash is asserted in this draft.

UPDATE_MODEL:
  strategy: versioned_incremental
  triggers: [new_evidence, policy_change, tool_change, schema_change, execution_feedback]
  procedure: validate -> diff -> assess_compatibility -> version -> publish -> audit
  rollback: Restore last validated version if integrity checks fail.

AI_CONSUMPTION:
  representation: typed_machine_readable_flow
  modes: [reasoning, planning, execution_validation, retrieval, audit]
  execution_policy: Treat ontology rules as a specification, not permission to run tools.
  required_checks: [type_check, permission_check, approval_check, dependency_check, evidence_check]
  output: {plan_id: str, execution_status: str, evidence_refs: list[str], uncertainties: list[str]}

VALIDATION:
  - All relationship endpoints resolve to declared types.
  - All required fields and enum values are valid.
  - Dependency graphs contain no unhandled cycles.
  - Executions obey authorisation and approval constraints.
  - Provenance is attached to derived or externally sourced assertions.
  - The published FLOW_HASH is reproducible from canonical content.

END FLOW ALGEBRA