🤖 AI

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

This paper introduces the "process harness," a mechanism that integrates a policy-governed agentic layer around existing deterministic workflow engines to enable Agentic BPM, rigorously defined by the Task-Decision-Flow (TDF) model and realized in the CUGA FLO system to balance structural compliance with adaptive, policy-framed autonomy.

Original authors: Fabiana Fournier, Lior Limonad

Published 2026-06-26

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Fabiana Fournier, Lior Limonad

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very strict, old-fashioned factory assembly line. This line is built to be perfect: it follows a fixed map, every step is pre-programmed, and it never makes mistakes. However, it's also incredibly rigid. If a box arrives that doesn't fit the standard size, or if a new rule suddenly appears from the government, the machine stops, breaks, or needs a human to climb in and manually fix it.

This is how most business software (called BPM) works today. It's great for routine tasks but terrible at handling surprises.

Now, imagine you could give this factory a "smart supervisor" who can read, think, and make judgment calls, but who cannot touch the conveyor belt or change the machine's gears. This supervisor can only shout instructions to the human operators or suggest small detours, but the machine itself still runs the show.

This paper introduces a new system called CUGA FLO that does exactly this. It calls this system a "Process Harness."

Here is how it works, broken down into simple concepts:

1. The Core Idea: The Harness

Think of a horse. The horse is the engine (the old workflow system). The harness is the gear you put on the horse to guide it. You don't replace the horse; you just add a layer of control on top.

The Old Way: To handle a surprise, you had to redesign the whole factory floor (the software code) before the surprise happened.
The New Way (CUGA FLO): You keep the factory exactly as it is. You wrap a "Process Harness" around it. This harness uses AI (specifically Large Language Models) to watch the process. When the process hits a specific checkpoint, the AI steps in, thinks about the situation based on a set of written rules (policies), and suggests what to do next.

2. The Three "Smart Assistants"

The paper says this harness uses three different types of AI assistants, each with a specific job. They are like a team of specialized managers:

The Task Agent (The Worker):
- Job: Doing the actual work.
- Analogy: Imagine a task is "Check the applicant's credit score." In the old system, a computer script did this. Now, the Task Agent reads the messy financial documents, understands them, and calculates the score.
- Rule: It has a strict policy: "You can calculate the score, but you are not allowed to say 'Approved' or 'Rejected'." That decision belongs to someone else.
The Decision Agent (The Traffic Cop):
- Job: Deciding which path to take at a fork in the road.
- Analogy: The assembly line splits into two paths: "Approve" or "Reject." The Decision Agent looks at the score the Task Agent just made. It checks the rules (e.g., "If the score is above 0.6, go left"). It then tells the machine which path to take.
- Rule: It makes sure the decision is logical and follows the written policy.
The Flow Agent (The Emergency Manager):
- Job: Changing the map while the process is running.
- Analogy: This is the most powerful one. Imagine a special "Hook" (a trapdoor) on the assembly line. If a specific situation happens (like a VIP customer or a regulatory emergency), the Flow Agent jumps in. It can say, "Skip the next three steps," "Stop the line," or "Add a new step right here."
- Rule: It can only do things that are explicitly allowed by a "Hook Policy." It can't just change the map randomly; it must follow the rules.

3. The "FRAME" (The Rulebook)

How do we make sure the AI doesn't go crazy? The paper introduces the FRAME.

Think of the FRAME as a giant, human-readable rulebook (written in plain English, like a Markdown file). Every time an AI assistant makes a decision, it has to check this rulebook first.

The Task Agent checks the "Task Rules."
The Decision Agent checks the "Routing Rules."
The Flow Agent checks the "Emergency Rules."

If the AI tries to do something not allowed in the rulebook, the system stops it. This ensures the AI is "framed" by human rules, not just making things up.

4. The Loan Approval Example

The paper proves this works with a Loan Approval example:

The Worker (Task Agent) reads a loan application and calculates a credit score.
The Traffic Cop (Decision Agent) sees the score is high (0.82) and says, "Okay, this looks good, let's go to the 'Approve' path."
The Emergency Manager (Flow Agent) sees the applicant's ID number is "4321." Even though the score is high, the rulebook says, "ID 4321 is banned due to a new regulation."
The Result: The Flow Agent overrides the Traffic Cop's decision. It uses a "Hook" to instantly jump the process to the "Reject" path, skipping the approval steps entirely.

Why is this cool? In the old system, you would have had to build a special "ID 4321" path into the software years ago. With CUGA FLO, you just update the text file (the policy) today, and the system handles it immediately without rewriting the code.

5. Why This Matters (The "Best of Both Worlds")

The paper argues that this solves a big problem:

Old Systems are safe and structured but can't adapt to new things.
Pure AI can adapt to anything but is risky, unpredictable, and hard to audit.

CUGA FLO combines them. The "Engine" (the old software) guarantees the structure is safe and follows the map. The "Harness" (the AI) adds the ability to adapt, reason, and handle surprises, but only within the strict boundaries of the rulebook.

Summary

The paper presents CUGA FLO as a way to upgrade old, rigid business software into a smart, adaptable system without throwing away the old software. It does this by wrapping the old system in a "Process Harness" that uses three types of AI agents (Workers, Traffic Cops, and Emergency Managers) who are strictly governed by a human-written rulebook (the FRAME). This allows businesses to handle unexpected situations automatically while still keeping a strict, auditable record of every decision.

Technical Summary: A Process Harness for Uplifting Legacy Workflows to Agentic BPM

1. Problem Statement

Conventional Business Process Management (BPM) systems, while providing rigorous structural guarantees, suffer from two fundamental limitations in dynamic environments:

Closed-World Regime: Every deviation from the nominal path must be anticipated and explicitly modeled at design time. Unanticipated situations (e.g., regulatory changes, novel applicant profiles) force the system into error states or require human intervention, often leading to "workarounds" that bypass formal processes.
Rigid Task Execution: Service tasks rely on fixed scripts incapable of adapting to unstructured inputs, while user tasks introduce throughput constraints. The engine itself lacks the capacity for open-ended reasoning or contextual adaptation.

While Large Language Models (LLMs) offer open-ended reasoning, current integration paradigms are insufficient. The "AI-augmented" paradigm (LLMs within specific tasks) leaves overall control flow rigid. Conversely, the "LLM-as-Planner" paradigm (LLMs generating execution plans outside the engine) lacks mechanisms to guarantee structural compliance, auditability, or adherence to compliance policies. There is a need for a system that reconciles the structural rigidity of deterministic workflow execution with the adaptive reasoning of policy-governed agents without replacing existing workflow engines.

2. Methodology: The Process Harness and TDF Model

The paper introduces the Process Harness, a mechanism that overlays a policy-governed agentic layer onto an existing deterministic workflow engine. This layer intercepts designated control points to contribute reasoning, adaptation, and oversight while the engine retains structural authority.

The conceptual underpinning is the Task–Decision–Flow (TDF) model, which decomposes LLM reasoning across three distinct, policy-bounded agent types:

TaskAgent: Responsible for knowledge-intensive task execution. It replaces hard-coded scripts with policy-governed LLM execution, reasoning within a specific task policy ( $C_T$ ) to produce domain outputs.
DecisionAgent: Responsible for per-case gateway routing. It replaces static condition evaluation with LLM reasoning bounded by a decision policy ( $C_D$ ). Crucially, it mandates a deterministic condition-evaluation step before reasoning to ensure the gateway condition is explicitly assessed.
FlowAgent: Responsible for runtime flow adaptation via a principled hook mechanism. It intercepts designated sequence flows (hooks) and reasons under hook policies ( $C_F$ ) to recommend structural interventions (e.g., skip, swap, terminate, or modify topology).

Governance Framework (FRAME):
All agent reasoning is bounded by the FRAME ( $F$ ), an aggregate set of human-readable policy documents. This ensures "framed autonomy," where agents operate within explicit, auditable constraints. A secondary governance layer, action_permissions ( $\phi$ ), explicitly enumerates which structural intervention types a FlowAgent is permitted to instruct, separating the LLM's reasoning from the engine's execution capabilities.

Architecture (CUGA FLO):
The paper presents CUGA FLO as the first realization of the TDF model.

Decoupling: The reasoning layer (FlowAgent and its sub-agents) is fully decoupled from the execution layer (WorkflowEngine) via a Model Context Protocol (MCP) Bridge (implemented as a FastMCP server).
Interaction: The workflow engine drives execution and pauses at control points (tasks, gateways, hooks) to invoke callbacks (execute_task, route_gateway, evaluate_hook). The FlowAgent processes these calls using ControlPointFlowKnowledge (process model, state, history) and returns structured recommendations.
Execution: The workflow engine enforces the structural conformance, applying the FlowAgent's recommendations (e.g., rewiring flows for skip_to or remove_node) without replaying executed nodes.

3. Key Contributions

The paper makes five specific contributions:

Process Harness Paradigm: Introduces a mechanism to uplift conventional workflow systems to Agentic BPM, characterized by structural conformance, policy accountability, and runtime adaptability.
Task–Decision–Flow (TDF) Model: A formal conceptual decomposition of LLM reasoning into three agent types (Task, Decision, Flow), each with distinct roles and policy constraints.
FRAME Instantiation: Formalizes the aggregate policy set ( $F$ ) governing TDF processes, demonstrating how partitioning policies across agent types enforces separation of concerns at the LLM level.
CUGA FLO Realization: Presents the first implementation of the process harness, featuring a hook mechanism for runtime adaptation and an MCP bridge that decouples reasoning from the replaceable workflow engine.
Empirical Demonstration: Validates the model using a loan approval workflow that exercises all three agent types and a regulatory override hook, showing how a hook can override a gateway decision based on a different criterion (e.g., applicant ID) without modifying the gateway policy.

4. Results and Evaluation

The paper demonstrates the system through a loan approval workflow case study:

Nominal Case: A standard credit check (TaskAgent) produces a score; a DecisionAgent routes based on a threshold; a FlowAgent hook confirms continuation.
Regulatory Override Case: A high-scoring applicant (ID 4321) is routed to approval by the DecisionAgent based on the score. However, the FlowAgent hook intercepts the "yes" flow, applies a regulatory policy (based on ID), and instructs a skip_to intervention to the rejection path.
Outcome: The system successfully handles the "long tail" of rare, context-specific variants (regulatory overrides) without modifying the underlying BPMN model. The DecisionAgent and FlowAgent operate under separate policies, ensuring that the routing logic and the regulatory override logic are independently auditable.

The results confirm that the process harness can reconcile imperative requirements (enforced by the engine) with normative requirements (enforced by policy-framed agents), enabling "open-world" adaptation while maintaining structural integrity.

5. Significance and Claims

The paper claims that the Process Harness represents a new form of instrumentation for enterprise AI systems. Its significance lies in:

Reconciling Tension: It resolves the trade-off between structural rigidity and open-ended flexibility by separating process topology (fixed, engine-enforced) from process adaptation (dynamic, policy-governed).
Incremental Modernization: It allows organizations to transform existing workflow systems into fully agentic ones incrementally and reversibly, without displacing the underlying engine.
Accountability: Unlike "LLM-as-Planner" approaches where execution traces may be non-deterministic or unlinked to a model, CUGA FLO provides a concrete accountability substrate. Every LLM call is associated with a governing policy document, and every intervention is recorded in the process knowledge tied to specific process elements, enabling auditability and diagnosis of non-compliance.
Open-World Adaptation: It moves exception handling from a design-time, closed-world activity (modeling every possible error path) to a runtime, open-world capability where the set of handleable situations is defined by the reasoning capacity of the policy documents.

The authors position CUGA FLO as the first realization of the Agentic BPM manifesto, providing a pragmatic framework for organizations to evolve from agent-augmented BPM to full Agentic BPM where agents govern the process end-to-end.