Skip to content

Workflow as Knowledge: Semantic Persistence for LLM-Mediated Workflows

🕒 Published (v1): 2026-07-09 17:40 UTC · Source: Arxiv · link

Why this paper was selected

Semantic persistence for LLM workflows via Lisp-based representation — novel knowledge layer for tool-using agents

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

This paper proposes a conceptual object model in which LLM-mediated workflow definitions, running instances, and inference records are treated as first-class persistent knowledge objects in a shared semantic substrate—rather than opaque executable code, logs, or conversation history. The central distinction is between derive (deterministic computation over workflow state) and infer (mediated LLM judgment under declared context), which separates auditable logic from probabilistic outputs. The contribution is representational and terminological, with implementation and formal semantics deferred to future work.

Problem

Existing LLM workflow systems (LangGraph, AgentSPEX, DSPy, aiFlows) achieve execution persistence—checkpoints, logs, traces—but not semantic persistence: workflow definitions live as source code, running instances as execution threads, and LLM outputs as unstructured logs or chat history. These artifacts cannot be queried together as a unified knowledge graph, and inference acts that shaped decisions remain structurally outside the knowledge objects they produced. Human deliberations vanish as UI events rather than being retained as typed, traversable records.

Method

The paper proposes a three-layer architecture: - Runtime service layer: model adapters, tools, retrieval, storage. - DSL-machine control layer: interprets declared workflow objects, mediates all model and tool calls, validates results, applies transitions, writes back to the substrate. - Semantic layer: workflow definitions, instances, inference records, approvals, panels, context snapshots—all as typed knowledge objects with stable identities and dependency links.

The core DSL primitives are: - (derive :result :from <available-state>) — deterministic, replayable computation; semantics are testable. - (infer :result :from <declared-context>) — mediated LLM judgment; produces an inference-record with explicit context snapshot, return type, validation, and capability policy.

The LLM fills declared infer slots but cannot directly introduce workflow transitions or execute external actions; the executor retains authority over transitions, and all model outputs are mediated before any external effect. The conceptual lens is drawn from Lisp/Symbolics Genera live-image environments: homoiconicity (forms close to the objects they denote), object identity, and reflective inspection applied to workflow objects rather than Lisp data.

Key semantic object kinds (Table 1): workflow-definition, workflow-instance, input-binding, resource-binding, context-snapshot, retrieval-record, derived-object, inference-record, tool-result-record, decision-record, approval-record, panel-record, dependency-link, supersession-link.

Key Contributions

  • The derive / infer semantic boundary as an explicit architectural distinction between deterministic computation and LLM-mediated judgment within a workflow DSL.
  • A typed semantic object schema (Table 1 & 2) giving workflow definitions, instances, inference records, approvals, and panel deliberations stable identity and queryability across execution boundaries.
  • The distinction between approval (an authorization gate) and panel (a structured deliberation with motion, arguments, decision, and context)—both as durable typed records, not ephemeral UI events.
  • The distinction between state (active, ephemeral during execution) and record (durable evidence after execution).
  • Semantic checkpointing: a workflow-instance persists in the knowledge substrate and can be resumed; prior panel-record results can be reused under a scoped compatibility policy.
  • A comparative framing of execution persistence vs. semantic persistence (Figure 2) that positions the proposal relative to LangGraph, AgentSPEX, provenance systems, and W3C PROV.

Results

No empirical results. The paper is explicitly a conceptual model proposal; it states: "Implementation and empirical evaluation are left for future work." No benchmarks, baselines, or quantitative comparisons are reported.

Limitations

  • No implementation exists; all claims are design commitments, not tested results.
  • Formal transition semantics are explicitly deferred ("remain future work").
  • Semantic persistence does not by itself imply accurate attribution, reproducibility, trust, or audit quality—these require additional mechanisms not addressed here.
  • Non-LLM nondeterminism (randomized algorithms, stochastic simulations) does not fit cleanly into the derive/infer split and may require a future primitive.
  • The model does not address explicit message, event, or channel objects for multi-agent communication.
  • The DSL vocabulary items capability/action and handoff/promotion are marked as "candidate refinement"—their semantics are not settled.
  • The paper does not evaluate how the proposed model interacts with existing production agent frameworks or what migration costs would be.

Relevance to Agentic AI / LLM Agents

This paper addresses a foundational representational problem in agentic systems: the gap between what a workflow executed and what can be inspected, resumed, or audited afterward. The derive/infer boundary directly tackles how agent systems should demarcate deterministic control logic from probabilistic LLM judgment—a critical concern for safe, auditable agents where LLM outputs influence branching decisions. The typed inference-record with explicit context snapshots is directly relevant to agent memory, provenance, and human-in-the-loop (HITL) accountability, complementing checkpoint-based systems like LangGraph by adding semantic rather than merely execution persistence. For researchers tracking agentic AI, this paper contributes vocabulary and a conceptual architecture for making LLM-mediated judgment first-class, inspectable, and composable within multi-step agent workflows.