Source-linked AI summary
STAGE: Stateful Translation to Agentic Graph Execution with Policy-Scoped Context and Deterministic Control
Mengxi Luo, Changjia Chen, An Cao, Zirong Huang, Wanyi Dai
TL;DR
Policy-governed agents must reason over evidence while reliably following complex authorized procedures. STAGE confines model judgment to policy-scoped graph nodes and assigns procedural control to deterministic coordination. Across benchmarks, it generally improves task success and repeated-run reliability, with the largest gains on deeper workflows.
Problem
Long, branching policies require agents to combine semantic reasoning with procedural state tracking, while growing context increases risks of omitted steps, misrouting, and unvalidated judgments.
Method
STAGE uses reviewed executable graphs whose nodes define bounded policy judgments, local context, permitted capabilities, typed results, and coordinator-enforced transitions.
Results
STAGE substantially improves task success and repeated-run reliability across public benchmarks and Smart Dispute, especially on deeper workflows.
Takeaways & Limitations
Policy-scoped context combined with deterministic procedural control improves the reliability of policy execution within the evaluated workflows.
Takeaways & Limitations
STAGE generally involves a model- and workflow-dependent token trade-off, with substantial input-token increases in several public-model settings.
Abstract
from arXiv · showhide
Policy-governed agents must interpret case evidence while following an authorized procedure. We present \textsc{Stage}, an executable-graph framework that confines model judgment to policy-scoped nodes while placing procedural control in deterministic code. At each node, the model receives task-relevant policy context and returns a typed result, while the coordinator enforces the reviewed execution contract. We evaluate \textsc{Stage} on SOP-Bench Referral Abuse, two $τ^2$-bench domains, and Smart Dispute, a proprietary banking benchmark. Compared with monolithic full-policy execution, \textsc{Stage} generally improves task success and repeated-run reliability across workflows of varying procedural complexity. The largest gains occur on the deeper Telecom and Smart Dispute workflows, where $\mathrm{Pass}^3$ increases by 7.5--55.0 and 57.2--65.7 percentage points, respectively, depending on the model. These results show that combining policy-scoped context with deterministic procedural control can improve the reliability of policy execution.
1 Introduction
Policy-following agents must combine semantic reasoning with reliable execution of long, branching procedures. STAGE addresses this by scoping model judgment to graph nodes while deterministic coordination controls policy execution.
- Long, branching, multi-stage policies force agents to track both semantic reasoning and procedural state.
- Growing context increases risks of omitted steps, misrouting, and propagation of unvalidated judgments.
- STAGE represents policies as explicit action and decision nodes connected by valid transitions.
- Each node receives only the context, state, and tools required for its local responsibility, while code owns procedural control.
- STAGE is evaluated against monolithic full-policy execution across public benchmarks and Smart Dispute, with larger gains on deeper, more conditional workflows.
2 Problem Formulation
The study separates graph-owned procedural control from policy localization to test their effects on success, reliability, token use, and robustness to longer execution chains.
- 2.1 Experimental Conditions: The baseline gives one agent the complete policy and control over both semantic reasoning and procedural progression.
- 2.1 Experimental Conditions: Graph with full policy uses the reviewed graph for execution while presenting the complete policy at every node.
- 2.1 Experimental Conditions: Node-scoped STAGE uses the same graph but gives each node only task-relevant policy context grounded in mapped source passages.
- 2.1 Experimental Conditions: Comparing the baseline with STAGE measures bounded node execution, coordinator-owned control, and localized policy context together.
- 2.1 Experimental Conditions: Comparing the two graph conditions isolates policy localization while holding control structure fixed.
- 2.2 Research Questions: RQ1 asks whether graph-structured execution improves task success and repeated-run reliability over monolithic full-policy execution.
- 2.2 Research Questions: RQ2 tests node-scoped context against complete-policy presentation for success, reliability, and token consumption under fixed control.
- 2.2 Research Questions: RQ3 examines how performance advantage and error composition vary with execution-chain length.
3 STAGE
STAGE constructs a reviewed, frozen execution graph from authoritative policy and executes bounded policy judgments through contracts validated and routed by a coordinator.
- An LLM-assisted procedure decomposes authoritative policy into bounded tasks, maps source passages, and authors candidate nodes and transitions.
- The candidate graph is validated, reviewed, and frozen before evaluation.
- Each node is an executable contract specifying a local judgment, permitted skills and tools, result validation, and failure behavior.
- At runtime, the coordinator supplies the node contract, case information, shared memory, and selected policy view to the model.
- The model returns a typed result with its judgment, supporting case-evidence references, and an outcome when required.
- The coordinator validates results and enforces graph-declared routing, retries, escalation, termination, and attempt limits.
4 Evaluation
STAGE is evaluated across four workflows with different procedural complexity under controlled comparisons using shared models, inputs, environments, and evaluators.
- The evaluation covers SOP-Bench Referral Abuse, shallower Retail and deeper Telecom workflows from τ^2-bench, and the deepest Smart Dispute workflow.
- Public workflows are evaluated with GPT-5.6 Luna, DeepSeek V4 Flash, Claude Haiku 4.5, and Sonnet 5.
- Smart Dispute is evaluated only with Claude Haiku 4.5 and Sonnet 5 because it contains proprietary banking knowledge.
- One reviewed and frozen graph is constructed for each workflow before evaluation.
- Within each comparison, the model, task input, environment, and evaluator remain the same.
- The protocol compares full-policy and node-scoped STAGE conditions, isolates policy-context effects under fixed graphs, and groups Smart Dispute outcomes by chain length.
- Pass1 measures single-run success, while Pass3 measures cases completed successfully in all three trials.
5 Results
STAGE generally improves task success and repeated-run reliability across workflows, with especially large gains on deeper Telecom and Smart Dispute procedures. Policy localization also improves reliability and can reduce input-token consumption, while long-horizon completion and runtime efficiency remain constrained.
- STAGE improves Referral Abuse repeated-run reliability most for weaker models: Luna’s Pass3 rises from 88.0% to 95.5%, and Haiku’s from 79.0% to 88.5%.
- 32.5 percentage points: DeepSeek’s Retail Pass1 gain is the largest, while Pass3 gains range from 15.0 to 25.0 points across models.
- Luna’s Telecom Pass1 increases from 47.5% to 90.0%, while Pass3 rises from 32.5% to 87.5%; gains remain visible for all four models.
- Smart Dispute gains are large: Haiku’s Pass1 rises from 14.3% to 74.3% and Pass3 from 11.4% to 68.6%, while Sonnet’s Pass3 rises from 14.3% to 80.0%.
- Under fixed graph control, node-scoped context raises Pass3 by 27.5 points for Haiku and 22.5 points for Sonnet, while reducing total token consumption by 37.8% and 56.8%.
- Smart Dispute gains peak on medium chains at +73.3 points for Haiku and +66.7 for Sonnet; long-chain accuracy declines, with execution/end errors remaining dominant.
- The current implementation is primarily a reliability and control mechanism rather than a token-reduction method because multiple node-scoped calls can increase output consumption.
- Luna’s Telecom input consumption decreases by 17.3% while Pass3 increases by 55 points, and Sonnet’s Smart Dispute input consumption decreases by 36.9% alongside a Pass3 increase from 14.3% to 80.0%.
6 Related Work
Prior policy-constrained agents commonly let a persistent agent select the next behavior and use an enforcement layer to judge permissibility. STAGE instead makes a reviewed executable procedure determine the active policy judgment and permitted progression through compliance-carrying nodes.
- Prior systems such as ShieldAgent and AgentLTL verify actions or traces against temporal rules, while other systems gate tool calls with generated, reviewed, or authored constraints.
- These approaches share a control boundary in which a persistent agent selects the next task-level behavior and an enforcement layer judges whether it may proceed.
- Workflow-oriented systems establish explicit workflow state and controller-mediated execution through reviewed SOP DAGs, executable paged programs, phase orchestration, or WCFGs.
- STAGE centers a compliance-carrying execution node that binds policy passages, case evidence, capabilities, outcomes, schemas, and failure or transition behavior.
- Within that reviewed interface, the model resolves a bounded semantic question while the coordinator enforces which judgment is active and how the procedure advances.
7 Conclusion
STAGE improves task success and repeated-run reliability by separating local model judgment from graph-owned execution control. Gains persist on long workflows, while remaining longest-chain failures concentrate in execution and terminal completion.
- STAGE substantially improves task success and repeated-run reliability over monolithic full-policy execution across public benchmarks and Smart Dispute.
- The Smart Dispute chain-length analysis shows that gains persist on long workflows and remove most errors from skipped or misordered procedural steps.
- Remaining failures on the longest chains are concentrated in execution and terminal completion.
- Node-scoped policy context improves success and repeated-run reliability while reducing total context processed relative to full-policy exposure.
- A conforming trace bounds, reviews, and audits the execution path but does not guarantee a correct semantic judgment.
A Policy-to-graph Construction
The policy-to-graph construction workflow uses LLM-assisted semantic authoring, policy-faithful graph reorganization, and deterministic checks before human review and freezing.
- LLM-assisted construction segments the policy, extracts procedural tasks, and authors nodes, routing, and shared memory.
- Candidate fan-in, fan-out, and convergence are reorganized through policy-faithful absorption, serialization, or duplication before rechecking.
- The resulting plan is deterministically compiled and validated before human review and freezing.
- Generation stops for review when no faithful graph reorganization is possible, rather than emitting an invented rule.
B Reconstructed Benchmark Graphs
The reconstructed benchmark graphs span compact to deeply conditional workflows, with Retail shallowest, Telecom broader and branched, and Smart Dispute longest and most conditional.
- SOP-Bench Referral Abuse: SOP-Bench Referral Abuse contains six sequential stages for risk calculation, violation classification, severity assessment, and enforcement.
- Telecom: Telecom contains 13 nodes and two decisions, adding wider request routing and a deeper technical-support branch.
- Smart Dispute: Smart Dispute contains 26 nodes and nine decisions, producing the longest and most conditional execution structure.
- Retail: Retail provides the shallowest routing structure among the reconstructed benchmark graphs.
- The benchmark graph panels include only non-sensitive node titles and outcome labels.