Skip to content

A Process Harness for Uplifting Legacy Workflows to Agentic BPM: Design and Realization in CUGA FLO

🕒 Published (v1): 2026-06-25 15:50 UTC · Source: Arxiv · link

Why this paper was selected

Process harness wraps legacy workflows with policy-governed agentic layer without engine replacement

Ask a follow-up

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

💬 Ask ChatGPT✦ Ask Claude

TL;DR

This paper introduces the process harness, an agentic overlay mechanism that wraps a deterministic workflow engine without replacing it, enabling legacy BPM systems to gain LLM-driven reasoning and runtime adaptability. The formalism is grounded in the Task–Decision–Flow (TDF) model, which partitions LLM responsibilities across three policy-governed agent types. CUGA FLO is the first concrete realization, demonstrated on a loan-approval workflow.

Problem

Classical BPM engines (Camunda, Flowable, etc.) enforce structural compliance but operate in a closed world: unanticipated situations—regulatory changes, novel case profiles—trigger escalation rather than adaptation. Augmenting individual tasks with LLMs leaves control flow rigid, while delegating planning entirely to an LLM-as-planner sacrifices structural conformance and auditability. No existing mechanism bridges deterministic process execution with open-world agentic reasoning at the governance level.

Method

The authors define a process harness as a TDF-based agentic layer placed around (not inside) a workflow engine. The engine retains ownership of the process graph; the harness intercepts designated control points (tasks, gateways, sequence flows) and invokes one of three policy-governed agent types:

  • TaskAgent \(a = (t, C_T, P, T_s, \lambda)\): replaces hard-coded service tasks with LLM execution bounded by a task policy.
  • DecisionAgent \(d = (g, C_D, P, T_s \cup \{\texttt{cond\_eval}\}, \lambda)\): replaces static gateway-condition evaluation with per-case LLM routing; must invoke `cond_eval(Cond(g), P)$ before reasoning.
  • FlowAgent \(f = (H, I_s, \varphi, C_F(h_k), P, T_s, \mu, \lambda)\): intercepts hooked sequence flows \(H \subseteq E\) and recommends structural interventions (skip, swap, insert, remove, halt) drawn from primitives \(I_s\), subject to a dual governance layer: hook policies \(C_F(h_k)\) inside the LLM loop, and a per-process access-control function \(\varphi: I_s \to \{\texttt{permitted}, \texttt{prohibited}\}\) enforced externally.

All agents share process knowledge \(P = (P^m, P^s, P^h)\) (model, state, history) at every invocation and reason within an explicit FRAME policy set \(F\). CUGA FLO implements this via the open-source CUGA agent harness, bridging agents to workflow engines through an MCP interface.

Key Contributions

  • Formalizes the Process Harness paradigm with three key properties: structural conformance, policy accountability, and runtime adaptability—positioning it distinctly from classical BPM (high conformance, low adaptability) and LLM-as-planner (low conformance, high adaptability).
  • Introduces the TDF model with full data schema (graph-theoretic process representation, agent tuple definitions) and execution semantics (\(\texttt{TaskRun}\), \(\texttt{DecisionRun}\), \(\texttt{FlowRun}\)).
  • Instantiates the FRAME concept as the aggregate policy set \(F\) partitioned across agent types, enforcing separation of normative concerns.
  • Presents CUGA FLO with a hook mechanism and MCP bridge that decouples agent reasoning from the workflow engine, making the engine replaceable.
  • Defines three composable, independently activatable autonomy levels (task delegation → routing delegation → flow adaptation).

Results

  • Demonstration on a loan approval workflow exercises all three agent types and a hook-driven regulatory override scenario.
  • No quantitative benchmark numbers are reported; the paper is a design-and-realization contribution with illustrative evaluation only.
  • Positioning claim (Figure 2): CUGA FLO achieves high structural conformance and high runtime adaptability simultaneously, a combination unoccupied by existing approaches.

Limitations

  • No empirical evaluation: no latency, throughput, or correctness metrics reported against baseline BPM systems or LLM-as-planner approaches.
  • Demonstration confined to a single small illustrative workflow; scalability to large, complex enterprise processes is unvalidated.
  • Correctness of agent reasoning (especially gateway routing) depends entirely on LLM reliability and policy quality; no formal verification of FRAME compliance is provided.
  • The TDF model is engine-agnostic by design, but the MCP bridge and hook mechanism are implemented specifically for CUGA; porting effort to other engines (Camunda, Flowable) is not quantified.
  • The closed-world assumption is removed for adaptation, but auditability of LLM-recommended interventions relies on policy-framing and logging rather than formal proof.

Relevance to Agentic AI / LLM Agents

This work contributes a concrete architectural pattern—the process harness—for deploying LLM agents in structured, compliance-sensitive environments without sacrificing the guarantees of deterministic execution. The dual-governance model (intra-loop policy framing + external access-control function \(\varphi\)) is directly relevant to the broader problem of constrained agentic autonomy and connects to ongoing work on framed autonomy, policy-governed multi-agent systems, and safe tool-use. For agent researchers, the TDF decomposition offers a principled vocabulary for assigning agent roles within a workflow graph—task execution, routing, and structural adaptation—that could inform designs for any multi-agent system operating over structured processes. The MCP bridge also situates this work within the emerging standard for agent–tool interoperability.