Workflow as Knowledge: Semantic Persistence for LLM-Mediated Workflows

Technical Breakdown§

Core Idea: Semantic Persistence for Workflows§

This paper introduces a conceptual model where LLM-mediated workflows are treated as first-class knowledge objects. Instead of being transient execution traces, workflow definitions, instances, inference records, context snapshots, and dependency relations are stored in a shared, persistent knowledge substrate. The key innovation is the semantic distinction between two types of operations:

• Derive: Deterministic computation over available state (e.g., arithmetic, string manipulation). No LLM involvement.
• Infer: LLM-mediated judgment under explicit context and capability policy (e.g., reasoning, generation).

This separation enables workflows to be inspectable, resumable, and reviewable.

Symbolic Forms and Object Identity§

The model is inspired by Lisp's symbolic expressions and the concept of object identity. Each workflow component (e.g., a step, a context snapshot) has a unique identity and can be referenced symbolically. This allows for dynamic introspection and modification of workflows at runtime.

Formal Representation§

A workflow can be represented as a directed graph where nodes are either derive or infer steps, and edges represent data dependencies. Each node holds:

• id: unique symbol
• type: "derive" or "infer"
• inputs: list of references to other nodes or literals
• output: result (computed or pending)
• context (for infer): declared context such as retrieved documents
• capability (for infer): allowed tools/LLM constraints

Implementation Sketch (Python)§

from typing import Any, Dict, List, Optional
from dataclasses import dataclass, field

@dataclass
class WorkflowNode:
    id: str
    node_type: str  # "derive" or "infer"
    inputs: List[str]  # references to other node IDs or literal values
    context: Optional[Dict[str, Any]] = None
    capability: Optional[Dict[str, Any]] = None
    output: Any = field(default=None, repr=False)
    status: str = "pending"  # pending, computed, failed

class KnowledgeGraph:
    def __init__(self):
        self.nodes: Dict[str, WorkflowNode] = {}
    
    def add_node(self, node: WorkflowNode):
        self.nodes[node.id] = node
    
    def execute(self, node_id: str):
        node = self.nodes[node_id]
        if node.status != "pending":
            return
        # resolve inputs
        resolved_inputs = [self.nodes[i].output if i in self.nodes else i for i in node.inputs]
        if node.node_type == "derive":
            # deterministic function: e.g., sum, concat
            node.output = self._derive(node.id, resolved_inputs)
        elif node.node_type == "infer":
            # LLM call with context and capability
            node.output = self._infer(node.id, resolved_inputs, node.context, node.capability)
        node.status = "computed"

Mathematical Formalism (Preliminary)§

Let $\mathcal{W}$ be a workflow with nodes $N = \{n_1, n_2, \dots\}$. Each node is a triple $(t, I, O)$ where $t \in \{\text{derive}, \text{infer}\}$, $I$ is a set of input references, and $O$ is the output value after execution. The execution order respects a partial order $\prec$ such that for any edge $n_i \to n_j$, $n_i \prec n_j$. The semantics of derive is a deterministic function $f: \text{inputs} \to \text{output}$ known at definition time. For infer:

$$\text{infer}(C, K, \pi) = \text{LLM}(\text{prompt}(C, K), \pi)$$

where $C$ is the context (e.g., retrieved documents), $K$ is the capability policy (e.g., allowed functions), and $\pi$ is a permission mask for executor-enforced safety.

Significance§

This model bridges workflow execution with knowledge representation, enabling persistence, auditing, and resumption. It lays the groundwork for formal verification and runtime transparency in LLM agents.