AI Workflow Ontology

FLOW ALGEBRA
AI Workflow Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/artificial-intelligence-infrastructure/ai-workflow-ontology-2.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "AIWorkflowOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ComputingOntology
SUBDOMAIN := ArtificialIntelligenceInfrastructure
ONTOLOGY := AIWorkflowOntology

# ---------- PRIMARY ENTITY ----------
ENTITY AIWorkflow {
    definition:
        "A structured and orchestrated sequence of data, model, evaluation,
         deployment and monitoring activities used to develop, operate and
         update artificial intelligence and machine learning systems.";

    objectives: [
        WorkflowAutomation,
        Reproducibility,
        DependencyManagement,
        ModelLifecycleControl,
        DataLineage,
        OperationalReliability,
        ContinuousImprovement
    ];
}

# ---------- CORE ENTITIES ----------
WorkflowEntity := {
    Workflow,
    Step,
    Task,
    Dependency,
    Artifact,
    Trigger,
    Condition,
    Parameter
};

AIArtifact := {
    Dataset,
    DatasetVersion,
    FeatureSet,
    ModelArtifact,
    ModelVersion,
    EvaluationResult,
    DeploymentArtifact
};

WorkflowActor := {
    User,
    Scheduler,
    Orchestrator,
    TrainingService,
    EvaluationService,
    ModelRegistry,
    DeploymentService,
    MonitoringSystem
};

WorkflowState := {
    Defined,
    Queued,
    Running,
    Paused,
    Completed,
    Failed,
    Cancelled
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
Workflow CONSISTS_OF Step;
Step MAY_DEPEND_ON OtherStep;
Step CONSUMES Artifact;
Step PRODUCES Artifact;
Trigger STARTS WorkflowOrStep;
Condition CONTROLS BranchOrExecution;
Orchestrator EXECUTES Workflow;
WorkflowRun HAS WorkflowState;
Artifact HAS Provenance;

# ---------- AI WORKFLOW FLOW ----------
AIObjective
    -> DefineWorkflow
    -> IdentifyInputs
    -> ResolveDependencies
    -> ValidateData
    -> PrepareFeatures
    -> TrainModel
    -> EvaluateModel
    -> RegisterModel
    -> ApproveOrReject
    -> DeployModel
    -> MonitorModelAndService
    -> TriggerUpdateOrRetraining;

# ---------- WORKFLOW ----------
Workflow :=
    DirectedGraph(
        Steps,
        Dependencies
    );

Workflow SHOULD_BE AcyclicUnlessLoopSemanticsExplicitlyDefined;

WorkflowDefinition MAY_INCLUDE {
    Inputs,
    Parameters,
    Steps,
    Conditions,
    Outputs,
    RetryPolicy
};

# ---------- STEP ----------
WorkflowStep :=
    UnitOfExecutableWork;

Step HAS {
    Identifier,
    Inputs,
    Outputs,
    ExecutionEnvironment,
    State
};

Step MAY_BE {
    DataStep,
    TrainingStep,
    EvaluationStep,
    RegistrationStep,
    DeploymentStep,
    MonitoringStep
};

# ---------- DEPENDENCY ----------
Dependency :=
    UpstreamStep
    -> DownstreamStep;

DownstreamStep MAY_START_WHEN RequiredDependenciesSatisfied;

Dependency MAY_BE {
    DataDependency,
    ControlDependency,
    ConditionalDependency
};

# ---------- DIRECTED ACYCLIC GRAPH ----------
WorkflowDAG :=
    DirectedGraphWithoutCycles;

TopologicalOrder :=
    ValidExecutionOrderRespectingDependencies;

Orchestrator MAY_EXECUTE IndependentStepsInParallel;

# ---------- INPUT ----------
WorkflowInput :=
    ExternalArtifactOrParameterRequiredByWorkflow;

Input MAY_INCLUDE {
    DatasetReference,
    CodeVersion,
    ModelReference,
    Configuration,
    SecretReference
};

# ---------- OUTPUT ----------
WorkflowOutput :=
    ArtifactOrResultProducedByWorkflow;

Output MAY_INCLUDE {
    ProcessedDataset,
    ModelVersion,
    EvaluationReport,
    DeploymentReference
};

# ---------- PARAMETER ----------
WorkflowParameter :=
    ConfigurableValueAffectingStepBehaviour;

Parameter MAY_BE {
    Hyperparameter,
    DataParameter,
    ResourceParameter,
    DeploymentParameter
};

ParameterValue SHOULD_BE RecordedForReproducibility;

# ---------- ARTIFACT ----------
Artifact :=
    PersistedInputOrOutputOfWorkflowStep;

Artifact HAS {
    Identifier,
    Version,
    Type,
    Provenance,
    Location
};

# ---------- PROVENANCE ----------
ArtifactProvenance :=
    {
        ProducingWorkflowRun,
        ProducingStep,
        InputArtifacts,
        CodeVersion,
        Parameters,
        Environment
    };

Provenance SUPPORTS LineageAndReproducibility;

# ---------- DATA INGESTION ----------
DataIngestionStep :=
    Source
    -> Extract
    -> Validate
    -> StoreVersionedData;

DataIngestion PRODUCES DatasetVersion;

# ---------- DATA VALIDATION ----------
DataValidationStep :=
    Dataset
    -> CheckSchema
    -> CheckQuality
    -> CheckConstraints
    -> ValidationResult;

IF CriticalValidationFails
THEN DownstreamTraining SHOULD_NOT_PROCEED;

# ---------- DATA PREPARATION ----------
DataPreparationStep :=
    DatasetVersion
    -> Clean
    -> Transform
    -> Encode
    -> FeatureSet;

TransformationConfiguration SHOULD_BE Versioned;

# ---------- FEATURE PIPELINE ----------
FeatureStep :=
    InputData
    -> FeatureTransformation
    -> FeatureSet;

FeatureSet MAY_BE StoredIn FeatureStore;

TrainingAndServing SHOULD_USE CompatibleFeatureDefinitions;

# ---------- TRAINING ----------
TrainingStep :=
    FeatureSetOrDataset
    + ModelDefinition
    + Hyperparameters
    -> TrainingRun
    -> ModelArtifact;

TrainingStep MAY_REQUEST {
    CPU,
    GPU,
    Memory,
    DistributedWorkers
};

# ---------- HYPERPARAMETER SEARCH ----------
HyperparameterWorkflow :=
    GenerateCandidateConfigurations
    -> ExecuteTrainingRuns
    -> EvaluateRuns
    -> SelectBestCandidate;

CandidateRuns MAY_EXECUTE InParallel;

# ---------- EVALUATION ----------
EvaluationStep :=
    ModelArtifact
    + EvaluationDataset
    -> Metrics
    -> EvaluationResult;

EvaluationResult MAY_INCLUDE {
    AccuracyMetric,
    ErrorMetric,
    RobustnessMetric,
    FairnessMetric,
    PerformanceMetric
};

# ---------- QUALITY GATE ----------
QualityGate :=
    EvaluationResult
    -> CompareWithAcceptanceCriteria
    -> PassOrFail;

IF QualityGateFails
THEN ProductionDeployment := blocked;

# ---------- MODEL REGISTRATION ----------
RegistrationStep :=
    ApprovedOrCandidateModelArtifact
    -> AttachMetadata
    -> AssignVersion
    -> StoreInModelRegistry;

ModelRegistry PRESERVES ModelLineage;

# ---------- APPROVAL ----------
ApprovalStep MAY_BE {
    AutomatedApproval,
    HumanApproval
};

Approval MAY_REQUIRE {
    EvaluationThreshold,
    SecurityReview,
    ComplianceReview,
    HumanDecision
};

# ---------- DEPLOYMENT ----------
DeploymentStep :=
    ModelVersion
    -> PackageOrSelectRuntime
    -> ProvisionServing
    -> Deploy
    -> VerifyHealth;

Deployment MAY_TARGET {
    Staging,
    Production,
    Edge,
    BatchEnvironment
};

# ---------- CANARY WORKFLOW ----------
CanaryDeploymentWorkflow :=
    DeployCandidateToSmallTrafficFraction
    -> MonitorMetrics
    -> CompareWithBaseline
    -> PromoteOrRollback;

# ---------- ROLLBACK ----------
RollbackStep :=
    DetectDeploymentFailureOrRegression
    -> RestorePreviousKnownGoodModelVersion;

Rollback SHOULD_PRESERVE DeploymentAuditTrail;

# ---------- MONITORING ----------
MonitoringStep MAY_COLLECT {
    ServiceLatency,
    ErrorRate,
    Throughput,
    InputDistribution,
    OutputDistribution,
    ModelQuality,
    Drift
};

MonitoringResult MAY_TRIGGER NewWorkflowRun;

# ---------- DRIFT ----------
DriftDetectionStep :=
    ProductionDataOrPredictions
    -> CompareWithReference
    -> DriftMetric
    -> DriftDecision;

IF DriftExceedsThreshold
THEN RetrainingTrigger MAY_FIRE;

# ---------- TRIGGER ----------
WorkflowTrigger MAY_BE {
    ManualTrigger,
    ScheduleTrigger,
    DataArrivalTrigger,
    CodeChangeTrigger,
    ModelChangeTrigger,
    DriftTrigger,
    PerformanceTrigger
};

Trigger CREATES WorkflowRun;

# ---------- SCHEDULE ----------
ScheduledWorkflow :=
    TimeRule
    -> TriggerWorkflowRun;

Schedule MAY_BE {
    Hourly,
    Daily,
    Weekly,
    Custom
};

# ---------- EVENT-DRIVEN WORKFLOW ----------
EventDrivenWorkflow :=
    Event
    -> EvaluateCondition
    -> StartWorkflowOrStep;

Event MAY_INCLUDE {
    NewDataset,
    NewCodeVersion,
    DriftDetected,
    ModelApproved
};

# ---------- CONDITIONAL BRANCH ----------
ConditionalBranch :=
    Condition
    -> IfTrueStep
    | IfFalseStep;

Condition MAY_DEPEND_ON UpstreamResult;

# ---------- PARALLELISM ----------
IndependentSteps MAY_RUN_IN Parallel;

ParallelExecution MAY_REDUCE WorkflowCompletionTime;

Parallelism IS_LIMITED_BY {
    Dependencies,
    ResourceCapacity,
    Quotas
};

# ---------- RETRY ----------
RetryPolicy MAY_DEFINE {
    MaximumAttempts,
    Delay,
    Backoff,
    RetryableErrorTypes
};

IF StepFailsWithRetryableError
THEN Orchestrator MAY_RETRY Step;

# ---------- IDEMPOTENCY ----------
WorkflowStep SHOULD_BE IdempotentWherePracticalForSafeRetry;

IdempotentStep :=
    RepeatedEquivalentExecutionProducesEquivalentIntendedState;

# ---------- FAILURE ----------
WorkflowFailure MAY_INCLUDE {
    DataFailure,
    ResourceFailure,
    TrainingFailure,
    EvaluationFailure,
    DeploymentFailure,
    DependencyFailure
};

Failure MAY_PROPAGATE_TO DependentSteps;

# ---------- RECOVERY ----------
WorkflowRecovery MAY_INCLUDE {
    RetryStep,
    ResumeFromCheckpoint,
    SkipOptionalStep,
    RollbackDeployment,
    RestartWorkflow
};

# ---------- CHECKPOINT ----------
LongRunningStep MAY_SAVE Checkpoint;

Checkpoint MAY_ALLOW ResumeWithoutRepeatingEntireStep;

# ---------- CACHING ----------
StepCache :=
    StoredOutputForEquivalentStepInputsAndConfiguration;

IF CacheKeyMatches
AND CachedArtifactValid
THEN StepExecution MAY_BE Skipped;

# ---------- CACHE KEY ----------
CacheKey MAY_INCLUDE {
    InputArtifactVersions,
    CodeVersion,
    Parameters,
    EnvironmentVersion
};

# ---------- ORCHESTRATOR ----------
WorkflowOrchestrator :=
    SystemManagingWorkflowSchedulingExecutionAndState;

Orchestrator MAY {
    ResolveDependencies,
    ScheduleSteps,
    AllocateResources,
    RetryFailures,
    RecordState,
    EmitEvents
};

# ---------- SCHEDULER ----------
Scheduler SELECTS ExecutionResourcesForReadyStep;

ResourceRequest MAY_INCLUDE {
    CPU,
    GPU,
    Memory,
    Storage,
    WorkerCount
};

# ---------- EXECUTION ENVIRONMENT ----------
StepExecutionEnvironment MAY_BE {
    Container,
    VirtualMachine,
    ManagedJobRuntime,
    ServerlessRuntime
};

EnvironmentVersion SHOULD_BE Recorded;

# ---------- SECRET ----------
Workflow MAY_REQUIRE SecretReference;

Secret SHOULD_BE RetrievedSecurelyAtRuntime;

SecretValue SHOULD_NOT_BE EmbeddedInWorkflowDefinitionOrLogs;

# ---------- OBSERVABILITY ----------
WorkflowObservability MAY_INCLUDE {
    RunState,
    StepState,
    Duration,
    QueueTime,
    RetryCount,
    ResourceUse,
    Error
};

# ---------- LOGGING ----------
WorkflowLog SHOULD_ASSOCIATE EntriesWith {
    WorkflowRun,
    Step,
    Timestamp
};

# ---------- TRACING ----------
WorkflowTrace :=
    EndToEndRecordOfStepDependenciesAndExecutionTiming;

Trace MAY_SUPPORT BottleneckDiagnosis;

# ---------- REPRODUCIBILITY ----------
ReproducibleWorkflowRun SHOULD_REFERENCE {
    WorkflowVersion,
    CodeVersion,
    DatasetVersion,
    Parameters,
    EnvironmentVersion,
    RandomSeedWhereRelevant
};

# ---------- VERSIONING ----------
WorkflowDefinition MAY_HAVE Version;

WorkflowVersion SHOULD_BE AssociatedWith WorkflowRun;

# ---------- CI/CD RELATIONSHIP ----------
AIWorkflow MAY_BE_TRIGGERED_BY SoftwareDeliveryPipeline;

CodeChange ->
    Test
    -> Train
    -> Evaluate
    -> ConditionalDeploy;

# ---------- CONTINUOUS TRAINING ----------
ContinuousTraining :=
    Trigger
    -> ValidateData
    -> Train
    -> Evaluate
    -> Register
    -> ConditionalDeploy;

ContinuousTraining SHOULD_HAVE QualityGates;

# ---------- HUMAN-IN-THE-LOOP ----------
HumanReview MAY_BE WorkflowStep;

HumanApproval MAY_BLOCK DownstreamStepUntilDecision;

# ---------- SECURITY ----------
AIWorkflowSecurity MAY_INCLUDE {
    Authentication,
    Authorisation,
    SecretManagement,
    ArtifactIntegrity,
    NetworkIsolation,
    Audit
};

# ---------- DATA PRIVACY ----------
WorkflowProcessingSensitiveData MAY_REQUIRE {
    AccessControl,
    Encryption,
    DataMinimisation,
    RetentionControl,
    ApprovedExecutionEnvironment
};

# ---------- GOVERNANCE ----------
WorkflowGovernance MAY_DEFINE {
    Ownership,
    ApprovalPolicy,
    Retention,
    ModelPromotionRules,
    AuditRequirements
};

# ---------- COST ----------
WorkflowCost :=
    SUM(StepComputeCost + StorageCost + NetworkCost);

CachedOrSkippedSteps MAY_REDUCE RepeatedCost;

# ---------- PERFORMANCE ----------
WorkflowPerformance MAY_BE_MEASURED_BY {
    TotalRunTime,
    QueueTime,
    StepDuration,
    FailureRate,
    RetryRate,
    ResourceUtilisation
};

CriticalPath :=
    LongestDependencyPathDeterminingMinimumWorkflowCompletionTime;

OptimisingNonCriticalStep MAY_NOT ReduceTotalRunTime;

# ---------- SEMANTIC REASONING ----------
IF ProcessContainsOrderedOrDependentAIDataModelAndDeploymentSteps
THEN AIWorkflowClassification := supported;

IF RequiredUpstreamStepFails
THEN DependentStep SHOULD_NOT_RUNUnlessRecoveryPolicyAllows;

IF DataValidationFailsCritically
THEN Training SHOULD_BE Blocked;

IF EvaluationFailsQualityGate
THEN ProductionDeployment SHOULD_BE Blocked;

IF DriftThresholdExceeded
THEN RetrainingWorkflow MAY_BE Triggered;

IF StepInputsCodeAndParametersUnchanged
AND ValidCachedOutputExists
THEN Step MAY_BE Skipped;

IF WorkflowRunLacksVersionedInputsAndEnvironment
THEN ReproducibilityConfidence := decrease;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "AI workflow" ~= "artificial intelligence workflow";
    "ML workflow" ~= "machine learning workflow";
    "AI pipeline" ~= "machine learning pipeline" WHEN context == orchestrated_lifecycle;
    "workflow step" ~= "pipeline step";
    "workflow orchestrator" ~= "pipeline orchestrator";
    "quality gate" ~= "model acceptance gate";
    "continuous training" ~= "automated retraining pipeline";
    "workflow DAG" ~= "directed acyclic workflow graph";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_WORKFLOW(q) ->
    IDENTIFY_STEPS_AND_DEPENDENCIES(q) ->
    IDENTIFY_INPUT_OUTPUT_ARTIFACTS(q) ->
    IDENTIFY_TRIGGERS_AND_CONDITIONS(q) ->
    IDENTIFY_TRAINING_EVALUATION_DEPLOYMENT(q) ->
    IDENTIFY_FAILURE_RECOVERY(q) ->
    IDENTIFY_PROVENANCE_SECURITY_OBSERVABILITY(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        workflow_structure_consistency,
        artifact_provenance,
        execution_evidence,
        semantic_consistency,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: AIWorkflow;
    ontology: AIWorkflowOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_workflow:
        validate
        -> identify_steps
        -> identify_dependencies
        -> identify_inputs_outputs
        -> verify_graph
        -> integrate;

    new_step:
        classify
        -> identify_inputs
        -> identify_outputs
        -> identify_resources
        -> identify_retry_policy
        -> integrate;

    new_workflow_run:
        record_workflow_version
        -> record_artifact_versions
        -> record_parameters
        -> record_step_states
        -> record_outputs
        -> integrate;

    workflow_revision:
        preserve_previous_version
        -> update_steps
        -> update_dependencies
        -> update_conditions
        -> recompute_critical_path
        -> recompute_confidence
        -> regenerate_flow_hash;

    conflict:
        preserve_provenance
        -> compare_workflow_and_execution_evidence
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + WorkflowEntity
    + AIArtifact
    + WorkflowActor
    + WorkflowState
    + WorkflowDAG
    + WorkflowOrchestrator
    + ContinuousTraining
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
AIWorkflowOntology
    -> DefineAIWorkflow
    -> VersionInputsAndConfiguration
    -> ResolveStepDependencies
    -> ValidateAndPrepareData
    -> TrainCandidateModel
    -> EvaluateAgainstQualityGates
    -> RegisterApprovedModel
    -> DeployToTargetEnvironment
    -> MonitorServiceAndModelBehaviour
    -> DetectDriftFailureOrChange
    -> TriggerRecoveryRetrainingOrRollback
    -> PreserveLineageAuditAndReproducibility
    -> MaintainAutomatedAILifecycle;

END FLOW