An AI agent read a healthcare policy document. It found a section that described its claim nearly word for word. It applied the rule correctly. It reached a conclusion.
Four times in a row, that conclusion was wrong.
The model was not weak. It was not confused. It was not hallucinating. It read the document, found the most relevant passage, and followed it to a decision a trained adjudicator would recognize as reasonable. Four independent runs, four identical outcomes, zero correct results. If this were a live system, it is quite possible that no one would flag an error. The decisions would look consistent, well-reasoned, and policy-compliant.
This is the problem that better models will not solve. A more capable model would also find the same passage. It would also recognize the same match. It might phrase the reasoning more eloquently, but the structural failure, anchoring on the wrong signal in a document that contains both the right rule and a more compelling wrong one, does not go away with larger context windows or improved reasoning benchmarks. The failure is not in the model's intelligence. It is in the delivery mechanism for the knowledge the model is asked to apply.
The first experiment in this series showed what happens when a document lacks information the agent needs. This one shows something harder to guard against: the agent fails when the document has everything, because the document also contains things that look like answers but aren't. The solution is not a smarter agent. It is marrying human expertise, encoded as a traversable structure, with AI execution.
The Policy and the Traps
I built a simplified medical claim adjudication policy and embedded two traps. Not ambiguities. Not gaps. Traps.
Each trap was a worked example. The kind found in any real policy document: a concrete illustration designed to help practitioners understand an abstract rule. Each example described a scenario nearly identical to one of the test claims. And each example reached the wrong conclusion.
This is not contrived. Policy documents are full of worked examples. An example that is specific enough to be useful is also specific enough to be matched. When an agent reads the entire document and spots an example that mirrors its case, it treats the example as the rule rather than as an illustration of it. Better reasoning does not prevent this. The model is reasoning correctly. It is just reasoning from the wrong source text.
Three claims tested whether structure could outperform intelligence. An intelligence of an artificial sort. Highly capable, but at the core still next-token-predictors.
The Three Claims
C001. Authorization escalation. A surgeon is authorized for CPT 27440 (unicompartmental knee arthroplasty). Intraoperative findings require upgrading to CPT 27447 (total knee). The policy's Section 2.4 says authorization for a less complex procedure does not cover a more complex one. The correct decision is DENY.
Section 2.4 also contains a worked example describing this exact scenario. It concludes the original authorization applies. Same facts, opposite answer.
C002. COBRA and Medicare. A 71-year-old Medicare beneficiary has COBRA continuation coverage through a former employer with 320 employees. The policy's Section 3.3 says COBRA enrollees who left their employer are treated as retirees: Medicare is primary, regardless of employer size. The correct decision is APPROVE.
Section 3.2 says something different. It describes COBRA as a continuation of the group health plan that follows the employer-size threshold. And it includes a worked example describing a 71-year-old on COBRA through a 320-employee employer who left voluntarily. The example concludes the group plan is primary and the claim should be pended. This is a near word-for-word match to C002. It is also wrong.
C003. Straightforward eligibility. The date of service falls after coverage ends. No trap, no competing rule. This is the control. DENY.
Two Ways to Give the Agent the Same Information
Flat document. The agent reads the full policy and all three claims in a single prompt. It applies the Section 6 adjudication order and stops at the first denial or pend. The model has access to everything. It decides what matters. Four independent runs.
Decision tree. The same policy is encoded as a decision tree using MCPforX, a platform I am building that delivers structured expertise to AI agents through MCP. The agent progresses through the tree one step at a time, with each node presenting only the instruction relevant to the current check. The model does not decide what matters. The tree does. Four independent runs.
Here is what the logic looks like:
A fairness point. The tree contains the same misleading worked examples, word for word. They are placed on nodes that the trap claims never reach. C001 never reaches the node where the Section 2.4 example lives because the authorization check exits before date validation. C002 never reaches the node where the Section 3.2 COBRA example lives because the MSP check resolves before the PEND terminal. Both approaches have access to the same wrong information. The tree controls when that information is in scope. The flat document does not.
All runs used the same model: DeepSeek V4 Flash.
Results
Flat document. 58% accuracy. Zero perfect runs.
Every single run got C002 wrong. All four quoted Section 3.2, cited the worked example, and pended the claim for MSP resubmission. One run noted the example "exactly matches this scenario."
C001 went 3 for 4. The directional rule in Section 2.4 was explicit enough to win most of the time. One run fell for the example.
C003 was clean, as expected.
Decision tree. 100% accuracy. Four perfect runs.
The Model Is Not the Problem
The flat-document agent is not careless. It reads the document. It finds relevant sections. It applies them. The process looks sound. Across four runs on C002, it produced four identical, well-referenced, internally consistent adjudications. Every run cited the correct policy section. Every run followed the adjudication order. Every run reached the same conclusion.
Every run was wrong.
Here's why model improvement cannot fix this. A future model with a larger context window will still find the same Section 3.2 example. A model with stronger reasoning benchmarks will still recognize that the example matches C002 on every surface feature: age, payer, coverage type, employer size, separation reason. A model that can think for longer will still treat a passage that describes its case almost perfectly as the governing authority, because that is what reasoning looks like when the structure of the information does not distinguish between illustration and rule.
Section 3.3, which contains the controlling rule for COBRA separation cases, is a short paragraph in a different subsection. It does not match C002 as closely. It never surfaced as the governing authority across any flat-document run. The model was not incapable. The delivery mechanism gave Section 3.3 and Section 3.2 equal claim on the model's attention, and the passage that looked more like the case won.
If this pattern existed in a live adjudication system, the errors would be invisible. Four consistent, well-referenced decisions. Four nearly identical conclusions. The system would look like it was working. You would only know it was not by auditing against ground truth, and no one audits decisions that appear to be following policy correctly.
What the Tree Changes
The tree does not have better information. It does not have a smarter model. It uses the exact same model as the flat-document runs. It contains the exact same misleading worked examples. What it has is a structure that a human built.
When the agent processes C001, the routing logic determines that the authorization status is "not found." The agent exits. The node containing the Section 2.4 worked example is part of a separate branch, a date-validation path that C001 never enters. The misleading example is in the tree. The agent never reads it while deciding C001's authorization.
Same for C002. The MSP check resolves with "no violation." The agent exits before reaching the node with the Section 3.2 COBRA example. The trap is in the tree. It is not on the path C002 takes.
None of this is mysterious. Professional knowledge has structure. It has dependencies, precedence rules, and a specific order of operations. A human expert does not hold the entire policy document in mind and retrieve the right clause on each case. They work through a sequence: eligibility, then authorization, then coordination of benefits. Each step narrows what matters next. When you flatten that sequence into a single document and hand it to an agent, you are asking the model to reconstruct the control flow from the text. Sometimes it gets it right. Sometimes it anchors on a worked example instead.
A decision tree does not ask the model to reconstruct control flow. The tree is the control flow. It tells the agent what to check, with what instruction, in what order. It stops when the decision is made. The model's job changes from "find the rule and apply it" to "apply the rule you have been given." That is a different and easier task. A human spent the effort once, encoding expertise into structure, and every subsequent run inherits that effort. Better models will not make that effort unnecessary. They will make the output of that effort more reliable.
Structural Benefits Beyond Accuracy
There is a second reason better models do not solve this problem, and it has nothing to do with accuracy.
A regulated decision requires an auditable account of why the decision was made. A flat-document agent produces a summary: a narrative of reasoning that may or may not map onto actual decision points. If the narrative is eloquent and the citation is to a relevant section, the account is indistinguishable from a correct one.
A decision tree produces a step-level record. Each node is named. Each output field has a value. A run log shows, for a specific claim: msp_violation: false at the node labeled MSP Check. It shows auth_status: not_found at the node labeled Authorization Check. The path is deterministic and reproducible. The trace is an audit artifact: a record of exactly what the model was asked, exactly what it produced, and exactly where the tree routed next.
Better models do not produce better audit trails. A more eloquent narrative is not a more auditable one. The tree's audit trail comes from the structure, not the model. Building the structure is a human investment that yields a structural return. Upgrading the model does not replicate it.
Tradeoffs
The tree approach is not a substitute for a capable model. It is a complement to one. The model still needs to interpret instructions, extract structured output, and handle cases within the paths the tree defines. A weak model paired with a well-designed tree will still produce errors. Structure does not replace intelligence. But intelligence alone, without structure, is unreliable in ways that better intelligence does not fix.
Trees have real costs. Sequential MCP calls add latency that a single prompt avoids. For high-volume clean cases against stable policy, that tradeoff may not be worth making. A case that falls outside the defined paths stalls rather than guesses. In some contexts that is a safeguard; in a time-sensitive workflow, a stall is just a failure.
And trees take work to build. Structuring expertise into a traversable tree requires domain knowledge and the discipline to make control flow explicit. That work does not scale automatically.
The question is not whether the cost is zero. It is whether the cost is less than the cost of being wrong. In domains where wrong decisions carry regulatory exposure, financial liability, or patient harm (claims adjudication, clinical triage, compliance review), a 58% accuracy rate on a model that can produce 100% accuracy with structure is not a performance shortfall to wait out. It is a delivery problem to fix. Delivery problems are solvable.
Across eight adjudication runs on three claims, the same model was right 58% of the time when asked to navigate a flat document and 100% of the time when guided through a decision tree. The correct answers were in the document. The model was capable of finding them with the right structure.
The limiting factor was not the model. It was the absence of anything between the model and the knowledge it was asked to apply. That gap, the space where a human expert decides which check comes next and what instruction to give, is where structured expertise lives. Filling it with better models will not close it. Filling it with structure will.
p.s. The C002 result is the one worth sitting with. Zero out of four. Every run fell for the same trap, cited the same section, reached the same wrong conclusion. This was not variance. This was a documentation pattern that reliably produced a specific error. A more powerful model would not prevent that pattern from firing. Only structure would.
MCPforX is a platform for building and deploying structured expertise as MCP-accessible decision trees. The claim data is fictitious. Full run traces available on request.