🤖 AI

Trace2Policy: From Expert Behavior Traces to Self-Evolving Decision Agents

Trace2Policy introduces an error-driven iterative skill refinement (EISR) framework that systematically recovers and improves expert decision rules into high-accuracy, deterministic Python code, outperforming both static LLM distillation and pure-LLM baselines in compliance-sensitive tasks while significantly reducing refinement costs.

Original authors: Junli Zha, Jinbo Wang, Chao Zhou, Xiang Song

Published 2026-06-10

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Junli Zha, Jinbo Wang, Chao Zhou, Xiang Song

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 a busy logistics company where expert auditors spend their days reviewing thousands of shipping claims. They look at photos, read reports, and decide: "Is this damage the carrier's fault, or the sender's?" These experts make these decisions based on a complex, unwritten set of mental rules they've learned over years. They know things like, "If the photo shows a torn box but the system says 'intact,' trust the photo," or "If the reviewer wrote a note starting with 'C:', it means they are secretly reassigning liability."

The problem is that these rules are stuck inside the experts' heads. If you try to teach a computer (an AI) to do this job just by showing it a few examples, it gets confused. It misses the subtle, hidden tricks the experts use.

Trace2Policy is a new system designed to solve this. Think of it as a "Rule Extraction and Refinement Machine." Here is how it works, using simple analogies:

1. The Detective Phase (Capturing Behavior)

First, the system acts like a silent detective. It watches the expert auditors work on their computers, recording every click, every screen they look at, and every note they type. It doesn't just record what they clicked; it tries to understand why they did it.

Analogy: Imagine a coach recording a master chef cooking a complex dish. The coach doesn't just write down "add salt"; they note, "The chef tasted the soup, frowned, and added a pinch of salt because the broth was too acidic."

2. The Drafting Phase (The First Attempt)

The system takes these recordings and asks a smart AI to write down the rules it thinks the chef is following.

The Problem: The first draft is usually shallow. It captures the obvious steps ("Check the box") but misses the deep, hidden logic ("Check the current code, not the original code, because the system updates in real-time").
The Result: This first draft (called "v1 Skills") is okay, but it only gets about 70% of the decisions right. It's like a student who memorized the textbook but hasn't learned the trick questions on the final exam.

3. The "EISR" Engine (The Magic Loop)

This is the core innovation. The system uses a process called EISR (Error-driven Iterative Skill Refinement).

How it works: The system runs the draft rules against a test set of cases. When it makes a mistake, it doesn't just say "Wrong." It acts like a strict editor:
1. Diagnose: It groups the mistakes. Are they "Missing" (no rule covered this)? "Wrong" (the rule existed but gave the wrong answer)? Or "Conflicting" (two rules fought each other)?
2. Patch: It writes a specific fix for that group of errors.
3. Safety Check (The Regression Gate): Before saving the fix, it runs the old correct cases again. If the new fix breaks anything that was working before, it throws the fix away.
Analogy: Imagine a mechanic fixing a car engine. Every time they tighten a bolt to fix a rattle, they immediately test the engine to make sure they didn't accidentally loosen the spark plugs. They keep doing this until the car runs perfectly without breaking anything else.

4. The "Trap Rules" Discovery

Through this loop, the system found "Trap Rules"—deep knowledge that no one could have written down in a single interview.

Example: One trap was that a specific code on the screen might look like "Shared Liability," but it was actually just a temporary label that changed from "Packaging Damage" five minutes ago. The experts knew to ignore the label and look at the action the reviewer took. The AI only learned this after making the mistake repeatedly and being corrected.

5. The Final Product: Compiled vs. Prompt

The paper makes a very specific and surprising claim about how the rules are used:

The Prompt Method: You can feed the rules to an AI as a long list of instructions (a "prompt"). This works, but it's like asking a genius to solve a math problem while reading a 50-page manual. It gets about 70% right.
The Compiled Method: The system translates those rules into a strict computer program (Python code). This is like turning the manual into a calculator that just does the math.
The Result: The "Compiled" version jumped to 79.6% accuracy. The paper argues that for these specific, rule-heavy tasks, the quality of the rules matters more than the intelligence of the AI. A smart AI following bad rules fails; a simple computer following perfect rules succeeds.

6. The "Flywheel" (Self-Improvement)

Once deployed, the system doesn't stop.

The Loop: Human auditors still review every case (as part of their normal job). The system compares its answer to the human's answer. If they disagree, the system flags it, analyzes the error, and automatically triggers another "EISR" round to fix the rule.
Cost: Doing this manually would take a human expert 70 hours per cycle. The automated version (Auto-EISR) does it for $5–$ 10 and takes a few hours.

Summary of Claims

What it does: Turns expert behavior into self-improving decision rules.
What it found:
- One-shot learning (asking AI once) fails to capture deep, hidden rules.
- Iterative error correction (EISR) finds "trap rules" that boost accuracy significantly.
- For these specific tasks, running the rules as a strict computer program is much better than asking an AI to read the rules as a prompt.
- Adding an AI "safety net" (letting the AI fix the rules when it's unsure) actually lowered accuracy in this specific case because the AI was too eager to reject claims, whereas the rules were perfectly tuned to the company's specific needs.
Scope: This was tested on a logistics company's damage claims (3,349 cases) and a few legal reasoning benchmarks. The authors do not claim this works for every type of decision, but specifically for tasks where experts follow systematic, implicit rules.

Technical Summary: Trace2Policy

Problem Statement

Enterprise decision tasks in domains like auditing, compliance, and contract review rely on expert judgment that is often tacit, systematic, and deeply intertwined with specific software system behaviors. Existing automation approaches face three primary gaps:

Knowledge Acquisition: Current GUI agents (e.g., CogAgent, SeeAct) learn how to operate interfaces (clicking, filling fields) but fail to extract the underlying decision logic or heuristics. Process mining discovers activity flows but not the "why" behind specific decisions.
Knowledge Refinement: One-shot extraction methods (LLM distillation, few-shot learning, or expert interviews) capture only surface-level procedures. They fail to uncover "deep knowledge"—such as system encoding conventions, implicit action semantics, and mismatches between claims and actions—leading to performance plateaus (often around 70%) and, in some cases, "authority displacement" where strong models degrade when forced to follow unrefined rules.
Knowledge Evolution: Most agent systems remain static after deployment. While self-evolving agent surveys exist, few mechanisms utilize the natural ground truth provided by existing human review workflows to enable continuous, low-cost adaptation to changing business conditions.

Methodology: Trace2Policy Framework

The authors propose Trace2Policy, an end-to-end framework that transforms raw expert behavior traces into self-evolving decision agents. The pipeline consists of five phases:

Phase 0–1: Behavior Capture and Structurization

Agent Observer: Passively captures multimodal expert behavior (window focus, mouse clicks with screenshots, keyboard input, browser events) and segments them into task-level trajectories using business anchors (e.g., waybill numbers).
VLM Structurization: A Vision-Language Model converts raw trajectories into structured decision records, extracting systems consulted, key observations, reasoning chains, and evidence.

Phase 2: Automated Policy Distillation

An LLM distills an initial policy (called Skills) from the structured records. This policy is an externalized, human-readable rule document (Markdown) organized into three layers:

Workflow Layer: Query order and parameters for systems.
Decision Layer: Path routing and judgment conditions.
Platform Layer: API schemas, field encodings, and login procedures.

Phase 3: EISR (Error-driven Iterative Skill Refinement)

The core innovation is EISR, a structured diagnose-and-patch loop that treats the rule document as the optimization target, not the model weights.

Execution & Comparison: The policy is executed on a validation set, and errors are identified against ground truth.
Structured Diagnosis: Errors are clustered by root cause into three types: MISSING (no rule covers the case), WRONG (rule prescribes the wrong action), or CONFLICT (contradictory rules).
Targeted Refinement: An LLM proposes patches for each cluster.
Regression Gate: Patches are accepted only if they pass a regression test, ensuring previously correct cases are not broken.

Auto-EISR: An LLM-driven variant where an "Executor" agent generates errors and "Diagnose/Refine" agents propose fixes, automating the process at a fraction of the human cost.

Phase 4: Production Deployment and Self-Evolution

The refined policy is deployed. Human auditors continue to review cases, providing natural ground truth at zero marginal cost. When similar errors accumulate (≥5 cases), an incremental EISR round is triggered to update the rules, creating a continuous improvement flywheel.

Key Contributions

Trace2Pipeline: A validated pipeline from raw traces to deployed agents, demonstrated in a 22-day production deployment at a major logistics carrier (3,349 audit cases).
EISR Algorithm: A rule-refinement method using LLMs as optimizers with regression-gated acceptance. It successfully uncovers "trap rules"—deep knowledge invisible to one-shot methods, such as:
- Encoding State Ambiguity: Distinguishing between current and original liability codes in system displays.
- Implicit Action Prefixes: Recognizing undocumented signals (e.g., "C:" prefixes) in text comments.
- Claim Mismatches: Differentiating between performing an action and accepting a specific claim.
Execution Form Observations: The paper identifies that rule quality is a more dominant performance lever than model capability.
- Compilation Gain: The same EISR-refined rules, when compiled into deterministic Python, outperform the same rules used as an LLM prompt by 9.8 percentage points (79.6% vs. 69.8%) in production.
- LLM Fallback Failure: On skewed-base-rate tasks, re-enabling an LLM fallback (a common design pattern) monotonically degrades accuracy because the LLM's prior does not match the calibrated, skewed distribution of the rule cascade.
Authority Displacement: Unrefined rules can actively harm strong LLMs (reducing accuracy by 7–9pp) by forcing them to follow incorrect heuristics, whereas EISR-refined rules close this gap.
Cost Efficiency: Auto-EISR achieves refinement performance comparable to human experts at $5–$ 10 per cycle versus ~70 expert-hours.

Results

Production Performance: The compiled EISR-refined pipeline achieved 79.6% accuracy on the training benchmark and 77.3% on a held-out set, outperforming the historical pure-LLM baseline (72.7%) and zero-shot baselines (43.8%).
Cross-Model Consistency: Across five different LLMs, the variance in performance attributable to the rule version (v1 vs. v8) exceeded the variance attributable to the model choice.
Cross-Domain Transfer: The refinement loop (Phase 3) was tested on public benchmarks (LegalBench hearsay, BPIC 2012) without re-engineering. On the LegalBench hearsay task, EISR refinement lifted accuracy from ~84% to 92.2%, recovering from an initial "overshoot" in Round 1.
Cost-Benefit: Auto-EISR reduced the cost of rule refinement by approximately 100x compared to human-in-the-loop refinement while maintaining comparable action accuracy.

Significance and Claims

The paper positions Trace2Policy as a Use-Inspired contribution, addressing a specific operational need in enterprise compliance. Its significance lies in:

Shifting the Optimization Target: Moving from optimizing model parameters or prompts to optimizing externalized, auditable, version-controlled rule documents.
Deep Knowledge Extraction: Demonstrating that iterative error analysis is necessary to surface system-specific conventions that one-shot methods miss.
Form-Bundle Observation: Highlighting that in compliance-sensitive, skewed-base-rate environments, the combination of refined rules + deterministic compilation yields superior results compared to LLM prompting or hybrid LLM fallbacks. The authors explicitly note this is a regime-specific observation and not a universal claim for all decision tasks.
Scalable Self-Evolution: Providing a mechanism for agents to evolve continuously using the natural feedback loop of existing human workflows, eliminating the need for costly, explicit reward labeling.

The authors remain modest, acknowledging limitations such as the single-domain primary study, modest held-out sample sizes, and the potential for "auditor anchoring" (where human reviewers might be influenced by the agent's initial recommendation). They call for future work to isolate the "form-only" component of the compilation gain and to conduct broader multi-domain validations.