Arbor Framework: Efficient Decision Traversal

• Arbor Framework is a logic-agnostic structured decision system that uses DAG-based, edge-list representation for robust decision tree traversal.
• It decomposes complex workflows into node-local evaluations, improving error traceability and mitigating context window overflow.
• Empirical evaluations in clinical triage show significant gains in turn accuracy, cost efficiency, and latency reduction compared to monolithic approaches.

Arbor Framework refers to a family of frameworks and algorithms spanning decision-tree navigation, autonomous agent cognition, structured research automation, and neural simulation, with prominent usage in reliable workflow traversal for critical applications such as healthcare triage. While related algorithms titled "Arbor" have appeared in high-energy physics, geometric search, and computational neuroscience, the Arbor Framework as described in the context of LLM-based high-stakes conversation workflows is a model- and logic-agnostic system for robust, efficient, and interpretable traversal of large decision graphs (Silva et al., 16 Feb 2026).

1. Rationale and Motivation

The Arbor Framework was developed to address the fragility of conventional monolithic, single-prompt approaches to structured decision processes in domains such as clinical triage. Monolithic approaches—serializing the entire decision tree and embedding it within a single prompt—encounter critical limitations:

• Lost-in-the-middle degradation: Key information placed deep within large prompts becomes inaccessible due to LLMs’ diminished capacity for mid-context recall.
• Context window overflow: High-complexity workflows, such as the 449-node, 980-edge clinical triage tree (≈120k tokens), exceed context window limitations of existing models.
• Entanglement of concerns: Simultaneously requiring the model to parse structure, track workflow state, evaluate branches, and generate language causes accuracy collapse as heterogeneity grows.
• Poor error traceability: Failures in branch-taking or output generation are difficult to localize. Empirical studies confirm that as tree size and prompt length increase, the accuracy and reliability of state tracking by LLMs degrade sharply (Silva et al., 16 Feb 2026).

2. Data Structures and Canonical Representation

Arbor standardizes decision trees using an edge-list (adjacency list) representation, supporting fast, dynamic lookups and model-agnostic orchestration. The formalism uses:

• Nodes $N = \{n_1, n_2, ..., n_k\}$.
• Edges $E = \{(u \to v) | u, v \in N \}$, each with:
  • transition_key (unique id)
  • node_from_key ($u$)
  • node_to_key ($v$)
  • question (predicate/condition for transition)
  • answer (required value for transition)
  • extra fields (context, flags).
  • Structural integrity is validated offline by (i) orphan node detection via reachability, (ii) reference consistency ($\forall (u \to v) \in E, v \in N$), and (iii) cycle detection using strongly connected components (Kosaraju) to guarantee acyclicity.

3. DAG-Based Orchestration and Node-Level Decomposition

At execution, Arbor treats the decision process as a DAG traversal, statefully maintaining the current node. Each step involves:

• Edge Retrieval: Only outgoing edges from the current node are retrieved, sharply limiting the context presented to the agent.
• Transition Evaluation: A specialized LLM call evaluates which edge—if any—should be taken, leveraging a prompt containing only the relevant local context, possible transitions, and structured conversation state.
• Response Generation: Once a terminal or “stay” node is reached, a second, separate LLM call synthesizes the user-facing message, using the node context, a reasoning scratchpad, and additional external data.

Pseudocode for traversal:

current_node ← initial_node while True: E_cur ← RETRIEVE_EDGES(node_from_key = current_node) if E_cur = ∅: break next_key ← EVALUATE_TRANSITION(current_node, E_cur, conversation, external_context) if next_key = stay_key: break else: current_node ← next_key end while response ← GENERATE_MESSAGE(current_node, conversation, evaluator_scratchpad)

This design achieves strict contextual isolation per node, eliminates off-path transitions, reduces total reasoning complexity, and introduces modularity for debugging and tracing errors.

4. LLM Call Architecture and Model-Agnosticism

Arbor decomposes model interaction into two disjoint, focused LLM calls per turn:

• Transition Evaluation: Deterministic, low-temperature call to select the next node/key, receiving only local node context and eligible outgoing edges. Conditioned to use chain-of-thought tracing and emit an explicit state choice.
• Response Generation: Higher-temperature call to synthesize natural language output from the node context, transition rationale, and conversation history. The framework is both logic-agnostic (the tree is pure data) and provider-agnostic (supports arbitrary model endpoints for different subtasks). This allows, for instance, using a reasoning-tuned LLM for node navigation and a lightweight model for message synthesis, or vice versa.

The system’s transition logic can be mathematically summarized (optional for implementors):

$$\text{score}_e = P(\text{edge} = e \mid \text{context})$$

with transition chosen as

$$\text{next\_edge} = \arg\max_{e \in E_{cur} \cup \{\text{stay}\}} \text{score}_e$$

5. Empirical Performance and Comparative Analysis

Arbor was benchmarked on 20 clinical triage conversations (174 annotated decision turns) using a 449-node, 980-edge decision tree. Baselines serialized the full tree in a single system prompt. Models evaluated include GPT-5 (various variants), GPT-4.1, Claude Sonnet 4.5, Gemini 3 Pro/Flash, DeepSeek V3.1, Qwen3 30B/235B; each configuration was run with 5 replicates per turn.

Aggregate metrics:

Metric	Arbor (mean ± SD)	Single-Prompt (mean ± SD)	Δ (Arbor – Baseline)
Turn Accuracy	88.23% (±7.66%)	58.80% (±22.59%)	+29.42 percentage points
Cost per Turn	$0.012 (±$0.011)	$0.166 (±$0.125)	14.4× lower
Latency per Turn	14.51s (±8.82s)	33.84s (±27.23s)	57.1% reduction

Performance variance among single-prompt baselines was extreme (accuracy 14.9%–82.8% depending on model capability and prompt), while Arbor compressed variance across models, with all models ≥66.7% accuracy and most proprietary models near 90% (Silva et al., 16 Feb 2026). This demonstrates that architectural decomposition can outperform brute model scaling for structured tasks and enables cost-effective deployment with smaller base models.

6. Key Insights, Limitations, and Future Directions

Key Insights:

• Decomposing decision-tree traversal into node-local evaluations stabilizes performance across diverse LLMs.
• Error traceability is improved by separating condition evaluation from message synthesis.
• Hybrid deployment (pairing models of differing strengths for logic/language) becomes practical through this separation.

Limitations:

• Sequential LLM calls per turn introduce minimal processing overhead, potentially suboptimal for real-time or high-frequency applications unless further optimized (e.g., through chain-of-thought pruning or asynchronous reply mechanisms).
• Arbor assumes only forward DAG traversal; native support for backtracking or explicit rollbacks remains an open extension for handling user-initiated corrections.
• Long conversations could result in state drift. Future work targets global state consistency checks and ensemble-based transition confidence scoring.

Possible Extensions: Real-time applications, explicit native backtracking, distillation of per-node transition evaluators, and broader workflow domains have been identified as natural avenues for further research.

7. Applications, Generalization, and Impact

Arbor’s architecture is domain- and model-agnostic. While developed and validated in healthcare triage, the edge-list plus DAG orchestration approach is applicable for:

• Compliance checklists
• Complex customer-support scripts
• Regulated workflow automation (financial, legal) A single data-format conversion suffices to onboard new decision logic, with no requirement for prompt engineering or retraining. Economic impact is significant: bounded, local context reduces per-turn costs by more than an order of magnitude relative to monolithic approaches, making high-reliability LLM workflows cost-competitive at scale.

Arbor enables smaller or open-weight models to match—and in some cases surpass—the accuracy of much larger models in structured settings, providing new deployment strategies for enterprise and critical domains (Silva et al., 16 Feb 2026).