Governed Hierarchical Memory and Uncertainty-Triggered Routing for Cost-Efficient Financial Sentiment Decision Support

Highlights

Please indicate how your work links to systems science via your contributions to sys-tems practice, theory, and or methodology.

• The study treats financial LLM decision support as a systems-control problem that jointly manages computational activation, shared-state admission, provenance, and resource constraints.
• It contributes an auditable control plane that uses an explicit input-ambiguity proxy to separate routine execution from episode-scoped collaborative escalation.

What are the main findings and/or the implications of the main findings?

• On the class-complete 2064-record disjoint remainder, the controller was within 0.0005 accuracy and 0.0006 macro-F1 of direct inference while using 63.57% fewer tokens than always-on collaboration.
• The results identify selective routing, rather than a demonstrated governance effect, as the source of token efficiency and motivate validation on harder state-dependent financial workflows.

Abstract

Financial decision-support systems must balance quality, cost, traceability, and controlled state reuse. Existing single-agent, retrieval-augmented, and always-on multi-agent pipelines leave the joint control of collaboration and shared-memory activation under-specified. The purpose of this study is to determine whether governed hierarchical memory with uncertainty-triggered routing can preserve financial sentiment quality while reducing coordination cost. We operationalize uncertainty with an input-derived ambiguity score: after a low-cost probe, below-threshold inputs short circuit, whereas flagged inputs escalate to governed collaboration. On the disjoint 2064-record remainder of Financial PhraseBank sentences_allagree, the proposed configuration achieves 0.9453 accuracy and 0.9364 macro-F1—within 0.0005 and 0.0006, respectively, of the direct baseline—while using 63.57% fewer tokens than always-on collaboration but 31.05% more than direct inference. Earlier 200-record development and agreement-shifted analyses are highly label-skewed and are treated as sensitivity evidence only. Ablations and trace audits identify routing as the measured source of efficiency; no isolated benchmark gain is attributable to the governance rule. Theoretically, the study separates computational activation from governed state reuse as control-plane mechanisms. Practically, managers can reserve collaboration for flagged inputs while retaining traceability, although the ambiguity proxy and governed-memory benefits require harder workflow validation.

1. Introduction

Financial decision support is not merely a prediction problem. In practical analyst workflows, a system must ingest heterogeneous evidence, decide whether external context is necessary, preserve provenance, avoid stale intermediate beliefs, and expose enough internal process information for post hoc review. These requirements are especially important in finance, where evidence sources are heterogeneous, market conditions are non-stationary, and downstream users often care about why an output was produced, not only what the output was. As a result, financial language intelligence should be studied as a systems problem with explicit constraints on coordination, cost, and auditability.

Large language model (LLM) agents and multi-agent systems have recently expanded the design space for complex task execution. Systems such as AutoGen, MetaGPT, ChatDev, and AgentScope illustrate role-specialized coordination and flexible workflow construction [1,2,3,4]. In parallel, long-horizon memory systems such as MemoryBank, MemGPT, Reflexion, and Voyager suggest that externalized state can improve continuity, self-correction, and experience reuse [5,6,7,8]. Retrieval-centered approaches, including GraphRAG and HippoRAG, further show that knowledge organization affects reasoning quality in multi-step settings [9,10]. Recent financial-agent evaluation work is also moving toward process-level and time-aware assessment, emphasizing that financial multi-agent systems should be evaluated not only by final answers but also by trajectory validity, temporal leakage control, and realistic workflow constraints [11]. Yet these lines of work often optimize individual components rather than the global control problem of when shared state should be trusted, when collaboration should be activated, and how cost should scale with uncertainty.

Prior systems illustrate the unresolved control gap concretely. AutoGen and MetaGPT make multi-role interaction programmable but normally expose collaboration as an available workflow rather than a case-level resource-allocation decision [1,2]. MemoryBank and MemGPT improve persistence, yet their primary objective is retaining useful context rather than deciding whether a tentative item is safe for cross-role reuse [5,6]. FrugalGPT demonstrates that learned cascades can route among language models to manage quality and cost, but it does not address when a common-backbone agent workflow should activate cross-role collaboration or admit shared intermediate state [12]. Financial platforms such as FinRobot and FinMem combine domain agents, tools, or layered memory, but do not isolate the joint effect of uncertainty-triggered escalation and governed shared-state admission under controlled cost accounting [13,14]. The present study addresses this intersection rather than proposing another additive collection of agents and memory modules.

This gap is especially visible in financial decision-support settings. A single-agent pipeline may be cheap and surprisingly competitive on routine cases, but it can become brittle when evidence is ambiguous or conflicting. A retrieval-augmented system may improve grounding, but it can also inject distracting context and increase token cost on routine inputs. An always-on multi-agent system offers richer coordination, but it often pays the price of collaborative reasoning for every case, including those that do not require it. From a systems perspective, the key challenge is therefore not whether multiple agents or memory can help in principle, but how to decide when these resources should be activated and what state should be globally reusable once generated.

In this paper, we study that challenge through a governed hierarchical memory architecture for financial decision support, evaluated in a controlled sentiment-classification setting. The central design principle is that collaboration should be available but not always active. Concretely, we cast execution as an uncertainty-triggered cascade-routing problem over progressively more expensive stages and operationalize uncertainty with a deterministic input-ambiguity proxy. The proposed system first runs a low-cost single-agent probe. If the input ambiguity score is below threshold and the probe returns a valid label, the system records a short-circuit trajectory and completes the task without escalating. Otherwise, it activates a governed collaborative path that can use shared memory and role-specialized reasoning. Shared memory is not treated as a free-write buffer. Instead, it is governed by explicit admission criteria intended to reduce contamination from weak or stale intermediate hypotheses. This framing is also aligned with emerging agentic-AI governance guidance, which treats autonomy, tool use, memory, delegation, and human accountability as interacting system risks rather than isolated model properties [15].

Our contribution is system-level rather than model-level. We do not introduce a new foundation model or a new training procedure. Instead, we contribute a coordination design that couples hierarchical state organization with cost-aware routing, provenance-carrying logs, and traceable execution. This orientation is important because financial deployments are often constrained by latency, auditability, and serving cost, making orchestration choices an important object of study alongside backbone-model choice. The empirical evidence in this paper should therefore be read as benchmark-bounded validation of the orchestration design rather than as comprehensive validation of a full financial decision-support system.

The main contributions of the paper are as follows:

• We formulate financial LLM decision support as a governed coordination problem that jointly requires answer quality, bounded cost, traceability, and controlled shared-state reuse. This formulation makes orchestration policy an explicit systems-science object. It treats quality, resource use, state integrity, and accountability as coupled operating constraints rather than independent model attributes.
• We present a governed hierarchical memory architecture that separates private episodic memory, governed shared memory, and structured knowledge support, and couples them through explicit read/write control. The separation assigns different access scopes and lifetimes to tentative local state and reusable global state. It defines an auditable admission structure whose benchmark instantiation is episode scoped and whose broader reliability benefit remains to be tested.
• We introduce an uncertainty-triggered cascade-routing policy that uses an input-derived ambiguity proxy to route routine cases through a cheap path while preserving a higher-cost collaborative path for flagged cases. This policy converts collaboration from an always-on capability into a measurable control decision. Its quality–cost behavior can be inspected through execution traces.
• We provide a class-complete evaluation on the 2064-record remainder of Financial PhraseBank sentences_allagree that is disjoint from the initial development slice, supplemented by repeated development-slice ablations and agreement-split sensitivity checks. Using a common backbone and decoding setup controls major model-level differences. The disjoint remainder supplies the primary quality–cost evidence, while the smaller slices test routing behavior and the persistence of the efficiency pattern under agreement shift.
• We analyze trace-level routing behavior and show that, on this slice, the observed efficiency gains follow from the logged short-circuit rate rather than an opaque aggregate cost difference. The trace analysis connects aggregate token savings to an auditable mechanism. It also distinguishes the measured contribution of routing from the still-unisolated benefit of memory governance.

The rest of the paper is organized as follows. Section 2 reviews prior work on multi-agent systems, memory architectures, retrieval infrastructure, and financial LLM systems. Section 3 defines the problem setting and design requirements. Section 4 presents the governed hierarchical memory architecture and the probe-first routing mechanism. Section 5 describes the evaluation protocol. Section 6 reports experimental results and trace-level analysis. Section 7 discusses system implications, limitations, and deployment considerations. Section 8 concludes.

2. Review of Literature

2.1. Multi-Agent LLM Systems

Multi-agent LLM systems have evolved from ad hoc conversational role assignment into programmable coordination substrates. AutoGen framed agent conversation as a reusable systems primitive for composing complex applications [1]. MetaGPT pushed this direction toward role specialization and standard operating procedures [2]. ChatDev demonstrated how structured multi-role interaction can support software-production workflows [3], while AgentScope emphasized experimental robustness and engineering abstractions for multi-agent development [4]. Related work such as CAMEL and role-play-based agent studies further indicates that coordination can improve decomposition, recovery from local errors, and workflow realism [16,17]. Even so, the dominant emphasis in this literature is on how to orchestrate interacting roles, not on how to control the lifecycle of shared intermediate states. In many implementations, conversation history is shared by default and treated as reusable once produced. Our work instead treats shared state as an object of explicit governance.

2.2. Memory for Long-Horizon Agents

The recent memory literature argues that fixed-window prompting is insufficient for persistent agent behavior. MemoryBank augments LLM agents with long-term memory to improve conversational continuity [5]. MemGPT recasts memory management as a systems abstraction and explicitly addresses context-window limits [6]. Reflexion uses verbal feedback as a memory signal for iterative self-improvement [7]. Voyager shows how externalized experience can support cumulative skill acquisition in embodied settings [8], and Generative Agents illustrates the joint role of memory, reflection, and planning in long-horizon behavior [18]. Collectively, these studies establish that memory is central to capable agents. However, they mainly optimize persistence, adaptation, and continuity. Our focus is different. In financial systems, the central question is not only what should be remembered, but also what may safely become a reusable shared state under uncertainty, freshness constraints, and audit requirements after the fact.

2.3. Retrieval and Knowledge Infrastructure

Retrieval-augmented generation has become a standard mechanism for grounding LLM outputs in external evidence [19]. More recent work suggests that retrieval quality depends not only on whether evidence is fetched, but also on how it is organized and when it is invoked. GraphRAG structures evidence through graph-based organization to improve query-focused synthesis [9]. HippoRAG models long-term knowledge access through structured associative mechanisms inspired by neurocognitive memory theory [10]. Self-reflective and tool-linked approaches further indicate that retrieval should be conditional rather than universal [20,21]. Adjacent cascade-routing work reaches a similar systems conclusion from the model-selection side: FrugalGPT learns combinations of models that trade quality against inference cost [12]. The present controller instead routes between execution paths built on one common backbone and couples escalation to episode-scoped state governance and audit logs. For financial decision support, retrieval or collaboration is valuable only when it improves the decision trajectory more than it increases prompt burden, distraction risk, or governance complexity. We therefore connect our design to selective-retrieval and adaptive-cascade perspectives: external support is treated as a controlled action within a larger control plane, not as default context expansion for every sample.

2.4. Financial LLM Systems and Agentic Finance

Finance has become a prominent application domain for LLMs and agentic systems. FinRobot proposes an open-source platform for financial applications built around LLM-based agents [13]. TradingAgents examines role-specialized financial reasoning and trading-oriented workflows [22]. FinMem explores layered memory for financial agents [14]. Parallel work on financial question answering, report-oriented reasoning, and financial opinion analysis further shows that domain-specific orchestration matters [23,24,25]. Recent evaluation-oriented work further argues that financial multi-agent systems are vulnerable to evaluation shortcuts such as temporal leakage, unrealistic information access, and weak trajectory validation [11]. This shift is important for the present paper because it supports a move from capability demonstrations toward controlled execution artifacts, cost accounting, and auditable routing. Yet much of the current literature still emphasizes capability expansion—more tools, more roles, more context—without making the control policy itself the primary object of study. Our paper instead centers the systems questions that remain under-specified in many financial agent designs: when to escalate, what to globalize, and how to preserve auditability while constraining cost.

2.5. Governance, Reliability, and Auditability

As LLM systems move toward deployment, controllability and reliability become first-class systems concerns. ReAct links reasoning and acting so that tool use and intermediate decision structure can be externally organized [21]. Constitutional and rule-constrained approaches argue that explicit control policies can improve behavior under deployment constraints [26]. Toolformer and related work demonstrate the value of selective external action rather than indiscriminate tool invocation [27]. Agentic-AI governance frameworks have also begun to emphasize risk controls for autonomous planning, tool use, memory, multi-agent delegation, transparency, and human accountability [15]. In high-stakes domains such as finance, however, governance must extend beyond prompt-level instruction. It must also include state admission rules, provenance retention, uncertainty-aware routing, and artifact-level inspectability after execution. This broader operational notion of governance is the conceptual basis of the present work.

2.6. Position of the Present Work

Our paper differs from prior work in two principal respects. First, it frames memory not as a generic persistence layer but as a governed shared state whose admission and reuse must be controlled. Second, it treats cost-aware routing as a first-class systems problem rather than as an implementation detail around a fixed agent architecture. We therefore position the contribution not as another additive combination of agents, memory, and retrieval, but as an integrated control architecture for uncertainty-triggered cascade routing, selective retrieval, and globally accountable state reuse. In that sense, the paper is closer to an adaptive inference and control-plane design for agent systems than to a simple capability-stacking multi-agent demo.

3. Problem Setting and Design Requirements

3.1. Task Setting

We study sentence-level financial sentiment classification as a controlled decision-support testbed. Given an input sentence x drawn from financial text, the system predicts a label $y\in \{\mathrm{positive},\mathrm{neutral},\mathrm{negative}\}$. Although the benchmark task is classification, our research objective is broader than label prediction alone. We use this setting because it enables controlled repeatability checks while retaining domain characteristics that matter for systems design: domain-specific language, evidence sensitivity, asymmetric class structure, and the need for auditable process traces. At the same time, the benchmark remains a narrow slice of financial decision support, so conclusions in the paper are limited to what this slice can substantiate.

In our setting, the system output is not only a predicted label. It also includes execution artifacts such as trajectory logs, memory logs, and risk logs. These artifacts are important because our claim is partly about system behavior. A financial decision-support system should expose enough process information for later inspection, especially when it selectively chooses between cheap and expensive reasoning paths.

3.2. Why This Is a Systems Problem

We formulate the task as a systems problem for four reasons. First, the environment is non-stationary. In realistic financial use, evidence freshness and relevance shift over time. Second, the evidence landscape is heterogeneous. Signals may come from text, retrieved documents, prior analyses, or external tools. Third, coordination cost matters. Multi-agent collaboration and retrieval calls consume tokens and latency, and these costs scale quickly in repeated use. Fourth, downstream users may require traceability. It is often important to know whether a result came from a cheap direct route, an evidence-augmented route, or a collaborative adjudication route.

These properties imply that the problem should not be reduced to a static prompt-engineering exercise. Instead, the system must manage state, route computation under uncertainty, and record process information in a way that remains inspectable.

3.3. System Requirements

Based on the deployment-oriented perspective above, we define five system requirements.

(R1)

Quality preservation: the system should not sacrifice task quality merely to reduce cost.

(R2)

Bounded resource usage: expensive retrieval and multi-agent collaboration should be avoided when unnecessary.

(R3)

Controlled shared-state reuse: information admitted into shared memory should satisfy explicit governance conditions.

(R4)

Trajectory-level auditability: routing decisions and intermediate actions should remain externally inspectable.

(R5)

Implementation portability: the approach should operate as an orchestration-layer design, not as a backbone-specific training method.

These requirements directly shape the architecture introduced in Section 4.

3.4. Threat Model for Coordination Failure

We also explicitly identify the main failure modes the system is designed to mitigate. The first is unnecessary escalation, where below-threshold cases trigger full collaborative reasoning and waste tokens. The second is shared-memory contamination, where tentative or weak intermediate conclusions become globally reused state. The third is retrieval distraction, where additional context harms rather than helps short-form classification. The fourth is auditability loss, where post hoc users cannot determine why a case took a certain execution path. The design is intended to target all four risks, although the present benchmark tests routing cost and traceability more directly than memory-contamination control.

4. System Design and Methods

4.1. Overview of the Architecture

Figure 1 summarizes the proposed architecture. The system combines a low-cost probe path with an escalation path that activates governed shared memory and collaborative reasoning only when needed. The architecture is intentionally conservative: it assumes that many benchmark cases can be solved without expensive coordination and therefore treats collaborative reasoning as a scarce resource.

Figure 1. High-level architecture of the proposed governed hierarchical memory system. The three panels show the progression from a cheap probe and input-ambiguity scoring, to governed route selection, to auditable output and provenance logging. The direct path is used when $a\left(x\right)<\tau$ after a valid probe label, whereas flagged inputs enter governed memory support and collaborative adjudication. Dark arrows show screening and common execution flow, green arrows show the direct route, purple arrows show escalation and governed-memory support, and the dashed amber arrow shows audit logging.

The design is motivated by a simple observation from practical LLM system building: if routine cases dominate the distribution, then always-on collaboration can incur unnecessary coordination tokens. The architecture therefore prioritizes selective activation. Below-threshold cases are resolved locally, while proxy-flagged cases retain access to richer coordination.

4.2. Agent Roles and Workflow

The implemented stack supports four conceptual functions even though all configurations use the same underlying backbone model. These functions are probe analysis, retrieval support, collaborative adjudication, and governance-aware logging. In the direct baseline, only probe analysis is used. In the retrieval baseline, a retrieval component augments the probe. In the always-on multi-agent baseline, collaborative adjudication is triggered for all cases. In the proposed system, collaborative adjudication becomes conditional on probe-label validity and an input-derived ambiguity score.

This arrangement is important because it lets us compare system-level routing decisions without confounding them with different backbone models. The proposed method is therefore best understood as a policy over execution paths and memory access, not as a separate model family.

4.3. Governed Hierarchical Memory

The central systems contribution is a three-layer memory organization.

4.3.1. Private Episodic Memory

This layer stores role-local, short-horizon information. It includes tentative interpretations, probe-level context, and information useful within a single execution episode that should not automatically influence other roles. In the benchmark implementation, this layer is represented by role-local prompts and outputs retained only within the current case; it is not a persistent cross-case store.

4.3.2. Governed Shared Memory

This layer stores information intended for cross-role reuse, but only after admission checks. Shared memory can reduce reconstruction within a workflow because later steps can reuse admitted state. However, an unrestricted buffer may amplify early mistakes. In the present benchmark, shared memory is episode scoped: candidate labels and admission decisions are summarized for the final adjudicator, and no state is carried from one sentence to another.

4.3.3. Structured Knowledge Support

This layer contains retrieval-facing knowledge resources and organized external evidence. In the current benchmark setting, the retrieval baseline uses a local processed retrieval corpus. More broadly, this layer represents the part of the system that interfaces with external evidence and structured contextual support.

This layered design is inspired by systems practice. Different state types should have different lifetimes, access scopes, and admission rules. Treating all context as a single flat buffer collapses these distinctions and makes downstream behavior harder to interpret.

4.4. Shared-Memory Governance

A crucial aspect of the method is that shared memory is write governed. In operational terms, information should not become globally reusable merely because one role produced it. Although the present benchmark task is lightweight, the design assumes deployment scenarios where evidence provenance, temporal validity, and uncertainty matter. Shared-memory governance therefore has at least four conceptual checks.

(G1)

Confidence check: the candidate item should be associated with sufficiently credible local evidence.

(G2)

Role and phase appropriateness: different stages of execution may have different permissions for globalizing intermediate state.

(G3)

Conflict awareness: the system should avoid admitting items that contradict stronger or more recent evidence without explicit adjudication.

(G4)

Audit metadata attachment: once admitted, a shared-memory item should remain attributable to an execution context, source, or trajectory event.

To make the governance rule explicit, we model each candidate shared-memory item m with an admission score

$$g\left(m\right)=\alpha c\left(m\right)+\beta f\left(m\right)+\gamma r\left(m\right)-\delta \kappa \left(m\right),$$

(1)

where $c\left(m\right)$ denotes confidence, $f\left(m\right)$ denotes freshness, $r\left(m\right)$ denotes source reliability, and $\kappa \left(m\right)$ is a conflict penalty with already admitted state. A candidate is written into governed shared memory only if

$$g\left(m\right)\ge {\tau }_{\mathrm{write}}.$$

(2)

The non-negative weights $\alpha$, $\beta$, $\gamma$, and $\delta$ determine the relative influence of confidence, freshness, reliability, and conflict, and ${\tau }_{\mathrm{write}}$ is the minimum admission score. These quantities are architectural parameters rather than fitted parameters in the present sentence-level experiment: the implemented benchmark records governance and risk events but does not numerically instantiate the full four-term admission score. A deployment should estimate the weights and threshold on a held-out validation stream against an application-specific loss for memory pollution and missed reuse, then freeze them before evaluation. Increasing $\alpha$, $\beta$, or $\gamma$ favors candidates strong on the corresponding positive criterion; increasing $\delta$ or ${\tau }_{\mathrm{write}}$ makes admission more conservative. Because the benchmark does not isolate these quantities, we do not attribute the reported quality or token differences to their numerical values.

The benchmark instantiates a narrower, fully deterministic admission rule. On an escalated case, three role prompts produce candidate labels. The implementation selects the label with the largest vote count and resolves a three-way tie by the lexicographically greatest label (positive > neutral > negative); candidates matching that selected label are marked write, whereas the others are marked rollback. Fixed role-reliability values are logged as metadata and freshness is set to one, but neither quantity changes admission in this experiment. The final governor receives the candidate summaries and their admission decisions, including rollback-marked summaries for audit visibility. Thus, the experiment evaluates episode-scoped vote-consistency admission labeling and its audit trail, not physical deletion of conflicting candidates, the complete deployment score in Equation (1), or longitudinal memory persistence.

Below-threshold inputs bypass the collaborative path after a valid probe prediction, while inputs meeting the ambiguity threshold trigger the more expensive episode-scoped path and its trajectory, memory, and risk logs. Figure 2 summarizes the broader conceptual admission pipeline intended for future stateful deployments. Its confidence, freshness/reliability, and conflict checks correspond to the positive and negative terms in Equation (1), while the admission branch represents Equation (2). The narrower benchmark implementation described above should not be read as an empirical test of every branch in this conceptual figure.

Figure 2. Conceptual governed shared-memory admission pipeline for stateful deployment. Candidate state is not globalized by default: it must pass confidence, freshness/reliability, and conflict checks before becoming reusable shared memory with attached audit metadata. The benchmark implements only the episode-scoped vote-consistency and audit portions of this broader design.

4.5. Probe-First Escalation and Budget-Aware Coordination

The proposed routing policy is probe first. Given an input instance x, the system runs a low-cost single-agent probe and computes a deterministic ambiguity score $a\left(x\right)$ from the input text. The score adds three points for exchange-announcement patterns, three for traffic–capacity comparisons containing at least two percentages, two for strong contrast combined with positive and negative polarity cues, one for weak contrast with a negative cue, and one for co-occurring positive and negative cues. Contrast-based points are suppressed for a small set of benign improvement transitions (e.g., moving from loss to profit). If the probe produces a valid sentiment label and $a\left(x\right)<\tau$, the system short circuits; otherwise, it activates the collaborative path. Thus, $a\left(x\right)$ is an interpretable task-specific proxy for input ambiguity, not a calibrated probability or a confidence value emitted by the language model.

We write the routing controller as

$$\pi \left(x\right)=\left\{\begin{array}{cc}\mathrm{direct},\hfill & a\left(x\right)<\tau \mathrm{and}\mathrm{the}\mathrm{probe}\mathrm{label}\mathrm{is}\mathrm{valid},\hfill \\ \mathrm{escalate},\hfill & a\left(x\right)\ge \tau \mathrm{or}\mathrm{the}\mathrm{probe}\mathrm{label}\mathrm{is}\mathrm{invalid},\hfill \end{array}\right.$$

(3)

Equation (3) defines the two routing outcomes. We write the expected inference cost under this policy as

$$\mathbb{E}\left[C\right]=Pr\left(\pi \left(x\right)=\mathrm{direct}\right)C_{\mathrm{direct}}+Pr\left(\pi \left(x\right)=\mathrm{escalate}\right)C_{\mathrm{escalate}},$$

(4)

where $C_{\mathrm{direct}}\ll C_{\mathrm{escalate}}$ in the intended operating regime. Equation (4) captures the core systems objective of the paper: if most inputs are routine, then selective escalation can preserve access to deep coordination while keeping average cost close to the direct baseline.

Here, $\tau$ is the minimum ambiguity score required for escalation, and $C_{\mathrm{direct}}$ and $C_{\mathrm{escalate}}$ are the per-case resource costs of the two paths. Larger $\tau$ is more permissive of direct execution because fewer inputs satisfy $a\left(x\right)\ge \tau$. The score components and the primary $\tau =1$ operating point are development-phase engineering choices, not learned or preregistered parameters; they were held fixed for the subsequent remainder run. In the ablation, $\tau \in \{1,3,4\}$: the observed short-circuit/escalation counts are 198/2, 198/2, and 200/0, respectively, and all reported all-agree quality metrics remain unchanged. Average tokens fall at $\tau =4$ because no case activates collaboration. This result establishes sensitivity of cost to this particular rule-based ambiguity gate; it does not establish calibration or transferability to other datasets, for which the scoring rules and threshold would require validation.

This policy creates a cheap-to-expensive hierarchy over computation. The idea resembles adaptive computation in other systems domains: most inputs should consume only the resources they need, while a small minority may justifiably trigger deeper processing. In our setting, the expensive path can involve additional multi-agent coordination and shared-memory use. Because routing decisions are logged, the policy is externally inspectable rather than hidden inside a monolithic prompt.

The cost-efficiency argument of the paper depends on this mechanism. Without selective escalation, multi-agent systems often pay coordination cost on every sample. With probe-first routing, the system pays collaborative cost only when the input-derived ambiguity proxy flags a case or the probe fails to return a valid label.

Figure 3 summarizes the implemented probe-first routing policy and its two execution paths.

Figure 3. Implemented probe-first escalation policy. A valid probe label with $a\left(x\right)<\tau$ selects the direct short-circuit path; $a\left(x\right)\ge \tau$ or an invalid probe label selects the more expensive support path. Only the latter activates collaborative reasoning and episode-scoped memory admission. Both paths terminate in a prediction with an audit trace, allowing the routing decision and its resource consequences to be inspected after execution. Blue arrows show the main execution routes, whereas the green arrow marks the additional shared-memory admission step on the escalation path.

4.6. Traceability, Risk Logging, and Auditability

A systems claim about governance is weak if it cannot be observed in execution artifacts. For this reason, the implementation records multiple log types. Trajectory logs capture action-level execution flow. Memory logs record state-related events. Risk logs capture annotations relevant to routing and governance interpretation. These artifacts are not post hoc decorations; they are part of the architecture.

Traceability matters for two reasons. First, it lets researchers verify whether the controller behaves as designed. Second, it provides a practical bridge toward deployment settings where users or auditors may need to understand whether a result came from a cheap local route or a more expensive collaborative route. The trace analysis in Section 6 uses these logs to verify route counts and admission outcomes.

To formalize this requirement, we define a lightweight auditability score for an execution trajectory $\tau$ as

$$\mathcal{A}\left(\tau \right)={\eta }_1{\mathrm{Cov}}_{\mathrm{traj}}\left(\tau \right)+{\eta }_2{\mathrm{Cov}}_{\mathrm{mem}}\left(\tau \right)+{\eta }_3{\mathrm{Cov}}_{\mathrm{risk}}\left(\tau \right),$$

(5)

where the three coverage terms measure whether trajectory, memory, and risk events are sufficiently recorded for post hoc inspection. In deployment settings, low $\mathcal{A}\left(\tau \right)$ should be treated as a governance failure even when the final prediction appears correct.

Specifically, ${\mathrm{Cov}}_{\mathrm{traj}}$, ${\mathrm{Cov}}_{\mathrm{mem}}$, and ${\mathrm{Cov}}_{\mathrm{risk}}$ are normalized coverage rates in $[0,1]$ for required trajectory, memory, and risk-log fields, and ${\eta }_1$, ${\eta }_2$, and ${\eta }_3$ are non-negative importance weights that sum to one. The present experiment reports the underlying trace counts rather than a calibrated composite score. In deployment, the weights should be set by the audit policy before evaluation; increasing one weight makes missing fields in that log class more consequential. Accordingly, Equation (5) is a transparent operational template, not an additional fitted outcome used to claim benchmark superiority.

Figure 4 complements the implemented routing diagram by showing the intended external-evidence extension. Screening precedes grounding and shared-memory linkage so that provenance and risk annotations remain attached instead of being lost in a flat prompt context; this branch is architectural rather than part of the proposed configuration’s reported runs.

Figure 4. Conceptual evidence-grounding and audit-trail extension. External evidence is screened for freshness and reliability, packaged for grounding, and then linked to governed shared memory with risk and audit annotations. The proposed configuration evaluated here does not activate this external-evidence branch.

4.7. Figure Preparation and Generative-AI Use

The paper figures are prepared from author-reviewed vector or slide-based source files and a reproducible drawing script included with the submission materials. During drafting, OpenAI GPT-5 was used only for visual ideation, style comparison, and language polishing. The final submission figures were manually redrawn, checked for text accuracy, and included only as explanatory diagrams of the system design and measured aggregate results. No AI-generated bitmap figure is used as empirical evidence, and the authors reviewed and take responsibility for all figure content.

4.8. Baselines and Configuration Matrix

We compare four configurations that share the same local serving endpoint and backbone model. Table 1 summarizes their system-level differences. The baseline matrix is intentionally simple so that the systems differences remain interpretable.

Table 1. Compared system configurations and their main system-level properties.

Method	Retrieval	Multi-Agent	Governed Shared Memory	Gated Escalation
b0_single_agent	No	No	No	No
b1_rag	Minimal four-item corpus	No	No	No
b2_multi_agent	No	Yes	No	No
ours_governed_memory	No (architecturally optional)	Yes (on demand)	Episode scoped	Yes

All methods use the same locally served 4-bit GPTQ checkpoint of Qwen3.5-35B-A3B through an OpenAI-compatible endpoint. Temperature is fixed at 0.0, thinking-mode output is disabled, and the generation budget per call is capped at 512 tokens. The direct baseline makes one model call. The retrieval control prepends the top three lexical-overlap matches from a fixed four-item, unlabeled demonstration corpus and then makes one call; it is a minimal context-augmentation control, not a competitive RAG system. The always-on baseline obtains three role-conditioned label votes and makes a fourth adjudication call. The proposed configuration first makes the direct probe call and, only on escalation, adds the same three role calls plus a governor call over episode-scoped admission summaries. This design controls the checkpoint and decoding settings while exposing the token consequences of different orchestration paths.

4.9. Why the Present Instantiation Is Still Meaningful

A possible concern is that sentence-level classification may be too small to justify a systems architecture. We argue that it is still useful as a controlled environment for validating routing behavior. If a routing mechanism shows measurable cost differences and inspectable traces in a simple setting, it becomes a candidate for follow-up evaluation in harder financial workflows. The current paper should therefore be read as a benchmark-bounded systems validation study rather than as the final word on financial multi-agent intelligence.

5. Experimental Protocol

5.1. Research Questions

To align the evaluation with the systems claims, we organize the empirical study around four research questions.

• RQ1: Can the proposed governed system preserve task quality relative to the strongest non-governed baselines?
• RQ2: Does probe-first escalation reduce resource usage relative to always-on multi-agent collaboration?
• RQ3: Is the observed efficiency gain supported by trace-level evidence showing that most cases are short-circuited rather than escalated?
• RQ4: What systems interpretation follows from the disjoint-remainder and development-slice behavior of retrieval, always-on collaboration, and governed on-demand collaboration?

5.2. Dataset and Evaluation Slices

We evaluate on Financial PhraseBank [28], a standard financial sentiment benchmark containing expert-labeled sentences. The initial development runs use the first 200 records of the sentences_allagree file, held fixed across seeds 7, 13, and 42. This is an ordered convenience slice rather than a random or stratified sample: it contains 195 positive and 5 neutral records and no negative record. We therefore use it only for controlled multi-seed comparison, trace inspection, and threshold ablation, and we do not treat its absolute quality metrics as representative of the full split.

To obtain a stronger confirmation set, we subsequently evaluate all 2064 all-agree records not included in the initial slice. This disjoint remainder contains 375 positive, 1386 neutral, and 303 negative records. Each of the four configurations is run once on the identical ordered remainder with temperature 0.0 and seed 7; the sample-ID SHA-256 manifest is identical across methods. The remainder was not used in the original 200-record development runs, but it was not a preregistered test set. It is the primary evidence for class-complete predictive performance and cost comparison, while the smaller development slice supports routing and ablation analysis.

To examine agreement shift, we also run checks on the first 200 records of sentences_75agree, sentences_66agree, and sentences_50agree. The respective label counts are 190/10/0, 181/19/0, and 174/25/1 for positive/neutral/negative, so these ordered slices remain strongly skewed and are not class-robustness tests. They use the same seeds, backbone, decoding settings, and logging pipeline and compare the direct single-agent baseline, always-on multi-agent baseline, and proposed controller. Because the agreement variants derive from the same corpus family and the slices are not independently sampled, we report them only as sensitivity checks and do not merge them with the disjoint-remainder result.

5.3. Metrics

We report both task-quality and systems-cost metrics. Task-quality metrics include accuracy, macro-F1, weighted-F1, and support-aware macro-F1. These measures are important because the class structure is imbalanced and simple accuracy alone can hide class-specific behavior. Recent work on preference-disaggregation-based multiclass insurance-fraud decision support provides a related example of multiclass operational evaluation using both aggregate and class-sensitive evidence [29]. That work develops a different classification methodology; we cite it for the evaluation context rather than as the source of the standard metric definitions below. We additionally track API-reported prompt-plus-completion tokens per example as an inference-resource proxy; we do not equate this measure with wall-clock latency, energy use, or monetary cost. Finally, for the proposed governed system, we inspect trajectory routing statistics to quantify how often the controller chooses the short-circuit path versus the escalation path.

Let K be the number of classes, N the number of samples, and $T{P}_k$, $F{P}_k$, $F{N}_k$, and $n_k$ the true positives, false positives, false negatives, and support for class k. We compute

$$\mathrm{Accuracy}={\displaystyle \frac{{\sum }_{k=1}^{K}T{P}_k}{N}},P_k={\displaystyle \frac{T{P}_k}{T{P}_k+F{P}_k}},R_k={\displaystyle \frac{T{P}_k}{T{P}_k+F{N}_k}},F{1}_k={\displaystyle \frac{2P_k{R}_k}{P_k+R_k}},$$

(6)

Equation (6) defines the per-class classification metrics, with zero-division terms assigned zero. Macro-F1 is $K^{-1}{\sum }_{k=1}^{K}F{1}_k$, weighted-F1 is $N^{-1}{\sum }_{k=1}^K{n}_{k}F{1}_k$, and support-aware macro-F1 averages $F{1}_k$ only over classes represented in the evaluated slice. Average token cost is $N^{-1}{\sum }_{i=1}^N(T_i^{\mathrm{prompt}}+T_i^{\mathrm{completion}})$. For the primary remainder, outputs are paired by sample ID; we tabulate discordant correctness counts and apply a two-sided exact McNemar test, equivalent to an exact binomial test with success probability 0.5 on the discordant pairs. The paired analysis is post hoc and is supplied as a reproducible script and CSV. These definitions make the reported quality and resource measures reproducible and distinguish the support-aware diagnostic from standard macro-F1.

To summarize system utility beyond task accuracy alone, we also interpret the results through the lens of a composite deployment objective,

$$\mathcal{J}=\mathcal{Q}-\lambda \tilde{C}-\mu \tilde{R},$$

(7)

where $\mathcal{Q}$ denotes normalized task quality, $\tilde{C}$ denotes normalized token cost, and $\tilde{R}$ denotes operational risk due to opaque or weakly governed execution. Although we do not claim a fully calibrated scalar score in the current benchmark, Equation (7) clarifies the systems viewpoint adopted in this paper: within a fixed benchmark and serving setup, a method is desirable when it preserves quality while reducing cost and maintaining inspectable execution.

The coefficients $\lambda \ge 0$ and $\mu \ge 0$ express stakeholder-specific exchange rates for normalized cost and risk relative to quality. They are not estimated or used to rank methods in the reported experiment. A practical deployment would map cost and risk to $[0,1]$ using predeclared validation-set bounds, elicit acceptable quality, cost, and audit-risk constraints from operators, choose $\lambda$ and $\mu$ on validation data, and perform a sensitivity analysis over plausible ranges. Larger $\lambda$ favors cheaper routes, whereas larger $\mu$ favors more strongly governed and inspectable execution; either can change the preferred operating point even when predictive quality is fixed.

This metric set reflects the systems orientation of the paper. The goal is not only to maximize answer quality but also to understand how quality, cost, and routing behavior interact.

5.4. Implementation Settings

All methods are run under the same local model-serving environment. The backbone is a 4-bit GPTQ checkpoint of Qwen3.5-35B-A3B accessed through a local OpenAI-compatible endpoint with thinking mode disabled. The decoding temperature is 0.0, maximum generation length is 512 tokens, and logging for traces, memory events, and risk events is enabled in the evaluated configurations. The retrieval baseline uses a local processed retrieval corpus with top-$k=3$. The multi-agent baseline activates collaborative reasoning without governed shared memory. The proposed configuration activates collaboration when the input ambiguity score meets the configured threshold or the probe label is invalid.

The corresponding systems lifecycle can be summarized as a compact execution pipeline: input ingestion, cheap probe inference, optional evidence support, governed state update, and trace-backed result emission. Figure 5 depicts this end-to-end lifecycle. This pipeline matters because it makes clear that the paper is evaluating a controlled workflow rather than an opaque monolithic prompt.

Figure 5. End-to-end controlled execution pipeline used in the evaluation. The workflow makes explicit where cheap inference ends, where optional support is activated, and where governed state updates are attached to the final auditable result. Blue arrows show the main execution routes, whereas the green arrow marks the support-to-governance transition.

5.5. Artifact-Preserving Evaluation and Aggregation

The evaluation preserves the exact run artifacts used for every reported result. The 200-record development comparisons aggregate three temperature-zero runs requested with seeds 7, 13, and 42, whereas the class-complete disjoint remainder uses one temperature-zero run per method with identical sample manifests. The aggregate export was checked against run-level metrics, and the supplementary package includes run-level metrics and selection manifests for the remainder comparison. This artifact-preserving procedure makes the evidence trail inspectable without implying that three same-stack requests substitute for broader model, dataset, or sampling validation.

6. Results

6.1. Disjoint Full-Remainder Results

Table 2 reports the class-complete evaluation on all 2064 all-agree records remaining after the 200-record development slice. The proposed controller achieves 0.9453 accuracy and 0.9364 macro-F1, differing from the direct single-agent baseline by only 0.0005 accuracy and 0.0006 macro-F1. It has higher point estimates than the minimal retrieval control and always-on multi-agent baseline on all reported quality metrics. Its average token use is 169.23 per example, 63.57% lower than always-on collaboration (464.53) but 31.05% higher than the direct baseline (129.13).

Table 2. Disjoint Financial PhraseBank all-agree remainder results on 2064 class-complete records (375 positive, 1386 neutral, and 303 negative), using one temperature-zero run per method (seed 7).

Method	Accuracy	Macro-F1	Weighted-F1	Support-Aware Macro-F1	Avg. Tokens
b0_single_agent	0.9457	0.9371	0.9469	0.9371	129.13
b1_rag	0.9288	0.9146	0.9288	0.9146	204.13
b2_multi_agent	0.9234	0.9137	0.9257	0.9137	464.53
ours_governed_memory	0.9453	0.9364	0.9464	0.9364	169.23

Note: Bold values indicate the best observed value in each column.

An item-level paired audit further clarifies these differences. The proposed and direct configurations have only seven discordant correctness outcomes: the direct baseline alone is correct on four and the proposed configuration alone on three (two-sided exact McNemar $p=1.000$). Against the minimal retrieval control, the corresponding counts are 78 and 112 in favor of the control and proposed configuration, respectively ($p=0.0164$); against always-on collaboration, they are 7 and 52 ($p<0.001$). These post hoc, unadjusted tests quantify paired benchmark differences but do not establish equivalence to the direct baseline or replace validation across models and datasets.

A route-stratified audit provides a stricter boundary. On the 149 escalated records, the separately executed direct baseline and proposed configuration produce identical final labels and are both correct on 148. All seven direct/proposed prediction disagreements occur among the 1915 short-circuit records, whose direct and probe outputs were generated in separate requests. Thus, the primary run does not show that escalation changed or improved a label, and the paired differences cannot be attributed to the collaborative branch.

The trace logs show 1915 short circuits and 149 escalations, giving ${\rho }_{\mathrm{esc}}=0.0722$. This class-complete result supports the paper’s bounded comparison with always-on collaboration more credibly than the development slice: selective routing retains nearly the direct baseline’s quality while avoiding most of the token use of always-on collaboration. However, direct inference has slightly higher quality point estimates and lower token use, so it is Pareto preferred on the measured quality–token axes in this benchmark. The controller’s distinct contribution is therefore a retained escalation mechanism and audit trail at substantially lower token use than always-on collaboration, not a superior observed operating point over direct inference. Moreover, all three role agents agreed on every escalated case, so all 447 candidate events were marked write and none rollback. The result therefore validates routing and logging under this protocol but does not empirically stress the conflict-handling benefit of governance.

6.2. Development-Slice Results

Table 3 reports the initial 200-record development-slice results. The direct baseline, always-on multi-agent baseline, and proposed system all reach identical mean accuracy (0.9900), macro-F1 (0.598291), weighted-F1 (0.9900), and support-aware macro-F1 (0.897436). The low macro-F1 is explained partly by the absence of negative examples, whose class F1 is assigned zero; support-aware macro-F1 averages only the two represented labels. These values characterize this fixed, highly skewed slice and should not be read as primary class-complete performance evidence.

Table 3. Initial Financial PhraseBank development-slice results on the first 200 ordered records (195 positive, 5 neutral, and 0 negative). Values are the mean ± population standard deviation across three temperature-zero runs requested with seeds 7, 13, and 42.

Method	Accuracy	Macro-F1	Weighted-F1	Support-Aware Macro-F1	Avg. Tokens
b0_single_agent	0.9900 ± 0.0000	0.598291 ± 0.000000	0.9900 ± 0.0000	0.897436 ± 0.000000	138.225 ± 0.000
b1_rag	0.9567 ± 0.0024	0.504445 ± 0.005016	0.966241 ± 0.001576	0.756667 ± 0.007523	213.050 ± 0.000
b2_multi_agent	0.9900 ± 0.0000	0.598291 ± 0.000000	0.9900 ± 0.0000	0.897436 ± 0.000000	500.900 ± 0.000
ours_governed_memory	0.9900 ± 0.0000	0.598291 ± 0.000000	0.9900 ± 0.0000	0.897436 ± 0.000000	143.965 ± 0.000

The immediate development-slice conclusion for RQ1 is that the proposed system preserves the strongest observed quality on these records. The disjoint remainder provides the stronger answer: the proposed system nearly matches the direct baseline and has higher point estimates than the other two implemented controls on class-complete quality metrics. Neither result establishes general superiority beyond the evaluated protocol.

6.3. Cost–Performance Trade-Off

The primary remainder comparison shows that the proposed system uses 63.57% fewer tokens than always-on collaboration and 17.10% fewer than the minimal retrieval control, while using 31.05% more than direct inference. On the much easier development slice, its 1% escalation rate narrows the direct-route premium to 4.15% and increases the savings relative to always-on collaboration to 71.26%. Figure 6 visualizes the primary remainder positioning. Table 4 reports both scopes so that the more favorable development result is not mistaken for the primary estimate.

Figure 6. Cost and macro-F1 positioning on the class-complete 2064-record disjoint remainder. The proposed configuration remains close to direct-inference quality, costs more than direct inference, and uses substantially fewer tokens than the implemented always-on collaboration baseline.

Table 4. Relative token-cost comparison of the proposed governed system. Positive values indicate higher cost than the reference; negative values indicate lower cost than the reference.

Evaluation Scope	Comparison	Relative Change in Avg. Tokens
Disjoint remainder	ours vs. b0_single_agent	+31.05%
Disjoint remainder	ours vs. b1_rag	−17.10%
Disjoint remainder	ours vs. b2_multi_agent	−63.57%
Development slice	ours vs. b0_single_agent	+4.15%
Development slice	ours vs. b1_rag	−32.43%
Development slice	ours vs. b2_multi_agent	−71.26%

These numbers answer RQ2. The proposed system retains the option of collaborative reasoning without paying collaborative cost on every example. The disjoint-remainder saving relative to always-on collaboration is the paper’s most direct empirical support. It shows that routing policy drives the observed token–quality trade-off under this protocol, while the independent contribution of governance remains unseparated.

6.4. Trace-Level Routing Evidence

Aggregate token savings are meaningful only if they correspond to actual routing behavior. Table 5 therefore reports the trace logs of the proposed system in both evaluation scopes. The disjoint remainder routes 1915 of 2064 cases directly and escalates 149; each development run routes 198 of 200 directly and escalates two.

Table 5. Trace-level routing statistics for the proposed system on the disjoint remainder and development slice.

Scope/Seed	Samples	Short-Circuit Cases	Escalated Cases	Escalation Ratio
Remainder/7	2064	1915	149	7.22%
Development/7	200	198	2	1.0%
Development/13	200	198	2	1.0%
Development/42	200	198	2	1.0%

To connect routing behavior to deployment control, we define an escalation pressure statistic

$${\rho }_{\mathrm{esc}}={\displaystyle \frac{N_{\mathrm{escalate}}}{N_{\mathrm{short}}+N_{\mathrm{escalate}}}},$$

(8)

Equation (8) summarizes how often the expensive path is invoked. Here, ${\rho }_{\mathrm{esc}}=0.0722$ on the primary remainder and 0.01 on the development slice, both substantially below the always-on rate of one.

Here, $N_{\mathrm{escalate}}$ and $N_{\mathrm{short}}$ denote the numbers of collaborative-path and short-circuit cases. The statistic is the empirical mixture weight on $C_{\mathrm{escalate}}$ in Equation (4); it therefore connects a trace-level routing decision directly to expected deployment cost. It is bounded in $[0,1]$, is interpretable as the fraction of cases consuming the expensive path, and can be monitored without access to ground-truth labels. Its limitation is equally important: a low value is desirable only when quality and risk constraints remain satisfied. Changes in the input distribution, ambiguity-score design, or threshold $\tau$ can raise or lower ${\rho }_{\mathrm{esc}}$, so operators should monitor it jointly with error and audit indicators rather than minimize it in isolation. On harder document-level tasks, a higher ${\rho }_{\mathrm{esc}}$ would narrow the cost advantage and would need to be justified by improved quality or risk control.

Figure 7 compares the observed direct-route concentration across the primary remainder and development runs.

Figure 7. Observed routing concentration in the primary disjoint remainder and the repeated development runs. The direct-route share is 92.8% on the remainder and 99.0% on each development run, explaining the different token premiums over direct inference.

This directly answers RQ3. The controller’s aggregate token use corresponds to logged route decisions rather than an unexplained total. Identical development counts across requested seeds are explained by the deterministic input rule together with valid probe labels in all cases; they confirm consistent routing logs for these runs but should not be interpreted as evidence of robustness to stochastic generation.

6.5. Agreement-Split Sensitivity Check

The main all-agree result leaves open a natural concern: the setting may be insufficiently challenging, so the observed token savings might not survive under lower annotator-agreement conditions. Table 6 examines this concern by repeating the comparison on the 75%, 66%, and 50% agreement variants. This supplemental check does not make the task fully representative of long-form financial analysis, but it does perturb the benchmark away from the cleanest agreement setting.

Table 6. Agreement-split sensitivity check on Financial PhraseBank. Each row reports the mean across three temperature-zero runs requested with seeds 7, 13, and 42 and 200 samples per run; the ordered slices are strongly label-skewed and are not class-robustness tests.

Split	Method	Accuracy	Macro-F1	Support-Aware Macro-F1	Avg. Tokens
75% agree	b0_single_agent	0.960	0.548	0.823	139.68
75% agree	b2_multi_agent	0.965	0.549	0.824	506.70
75% agree	ours_governed_memory	0.962	0.552	0.828	153.74
66% agree	b0_single_agent	0.925	0.541	0.812	139.09
66% agree	b2_multi_agent	0.940	0.556	0.833	504.34
66% agree	ours_governed_memory	0.930	0.547	0.821	155.81
50% agree	b0_single_agent	0.902	0.866	0.866	139.46
50% agree	b2_multi_agent	0.913	0.871	0.871	505.82
50% agree	ours_governed_memory	0.907	0.871	0.871	158.70

The sensitivity check clarifies the systems claim and its boundary. The proposed controller keeps average token usage far below always-on collaboration across all three slices: 69.66% lower on 75% agreement, 69.11% lower on 66% agreement, and 68.63% lower on 50% agreement. Routing counts are identical across the requested seeds, with 195/5, 194/6, and 193/7 short-circuit/escalation splits, respectively. Quality is close to the always-on baseline but not uniformly superior. Because these slices are also dominated by positive labels, the conservative interpretation is limited to agreement-shifted token behavior; class-complete quality evidence comes from Table 2.

Unlike the primary remainder, the agreement-split logs do exercise the rollback branch: each run records one rollback among 15, 18, and 21 candidate events for the 75%, 66%, and 50% slices, respectively. This observation verifies that the branch can be recorded, but it does not demonstrate a reliability benefit because these slices have no matched governance-off comparison and no outcome measure for contamination or conflict resolution.

Table 7 sharpens the evidence boundary of the paper. First, threshold sensitivity matters more for cost than for benchmark quality in the present setting: raising the gate threshold from $\tau =1$ to $\tau =4$ preserves all reported quality metrics while reducing average token usage from 143.97 to 138.23, a 3.99% decrease. Second, disabling governance does not materially change the benchmark metrics on this slice. The conservative interpretation is therefore not that governance independently improves sentence-level classification quality here, but that the current empirical support is strongest for cost-aware cascade routing, with governed shared state remaining a systems design choice whose broader benefits require harder tasks and richer process-level evaluation.

Table 7. Minimal ablation results for the proposed control architecture on the 200-record Financial PhraseBank development slice. Values are means across three temperature-zero runs requested with seeds 7, 13, and 42.

Method	Accuracy	Macro-F1	Support-Aware Macro-F1	Avg. Tokens
Governed memory ($\tau =1$)	0.990	0.598	0.897	143.97
Governed memory ($\tau =3$)	0.990	0.598	0.897	143.97
Governed memory ($\tau =4$)	0.990	0.598	0.897	138.23
Shared memory without governance	0.990	0.598	0.897	143.97
Gating only ($\tau =4$)	0.990	0.598	0.897	138.23

6.6. A Systems Interpretation of the Baseline Matrix

The baseline matrix together with the sensitivity and ablation tables reveals a more precise systems story. The four-item retrieval control underperforms direct inference while using more tokens, showing only that this minimal context augmentation adds no value on the evaluated task; it cannot support a general conclusion about modern RAG systems. Always-on collaboration is strongest or tied on some development and agreement-shifted slices but is weaker on the disjoint remainder and uses far more tokens throughout. The proposed method preserves a collaborative path for flagged cases while behaving like direct inference on most inputs. Read through a control-plane lens, the result is that selective routing is better aligned with this benchmark family than unconditional capability stacking when cost is part of the objective.

This answers RQ4. The relevant design question is not simply whether collaboration helps, but whether collaboration is activated under the right circumstances. The ablation results reinforce that interpretation: under the present protocol, routing policy changes can reduce cost without measurable quality loss, whereas governance-on versus governance-off does not separate the methods on benchmark accuracy. In this benchmark instantiation, the strongest operational evidence therefore favors ambiguity-triggered cascade routing, while claims about governance should be read as architectural motivation rather than as an isolated performance gain.

6.7. Why the Retrieval Baseline Likely Underperformed

Although the paper does not claim a definitive causal diagnosis, the minimal retrieval control offers one bounded observation. Financial PhraseBank sentences are short and label focused, while the control retrieves from only four fixed demonstration snippets. In this setting, the appended text increases prompt length without improving the reported metrics. This result characterizes the implemented control only and should not be used to rank richer retrievers, larger corpora, or learned retrieval policies.

This finding reinforces a narrower systems lesson from the present setup: retrieval need not be universally attached. In benchmark settings like this one, system design should ask not only “can external evidence be retrieved?” but also “is retrieval warranted for this case at this stage of execution?”

6.8. Token Cost of Always-On Collaboration in This Setting

The always-on multi-agent baseline provides an equally revealing contrast. It ties the proposed configuration on the development slice, is close on the agreement-shifted slices, and has lower quality point estimates on the disjoint remainder, while requiring four model calls for every case. At the aggregate level, unconditional collaborative voting therefore does not improve quality enough to offset its higher token use under this implementation and a token–quality objective.

The proposed method benefits precisely because it acknowledges this property of the data distribution. Instead of assuming that every sample deserves the same amount of deliberation, it uses a probe and input rule to decide whether to activate expensive collaboration. Across the evaluated scopes, the rule sends most inputs to the direct path. This is not evidence that multi-agent design is generally unnecessary; it is evidence that conditional allocation can reduce tokens in settings with similar, independently validated routing behavior.

6.9. Interpreting the Zero-Variance Pattern

An informative feature of the development runs is the near-zero variance for three configurations. For b0_single_agent, b2_multi_agent, and the proposed method, aggregate metrics are identical across seeds, which is unsurprising with temperature-zero decoding and a deterministic gate. The minimal retrieval control shows small non-zero variation, but the present artifacts do not identify its cause. These repetitions verify execution consistency under the current serving stack; they do not establish stochastic or cross-model robustness.

6.10. A Broader View of What the Results Mean

The headline result of the paper should not be interpreted as “multi-agent systems are unnecessary.” A more precise interpretation is that collaboration can be routed rather than assumed. The direct path handles 92.8% of the primary remainder and 99.0% of the development slice, so always-on coordination is difficult to justify under a token-cost objective for this benchmark and implementation. The value of the proposed system is that it preserves an escalation path without forcing every case through it.

This distinction matters for deployment framing, but only as a hypothesis carried forward from the benchmark. In real financial environments, system designers may face quotas on cost, latency, or concurrent throughput. The current study does not directly test those environments; rather, it suggests that reserving expensive reasoning for cases flagged by a validated routing signal is a plausible design direction even when benchmark accuracy does not exceed the strongest baseline.

7. Discussion, Limitations, and Deployment Considerations

7.1. Why Governed Memory Matters as a Systems Primitive

The main conceptual claim of the paper is that memory should be treated as governed state rather than as an undifferentiated persistence mechanism. In many agent systems, memory is introduced to increase continuity or reuse prior work. That is useful, but it is not enough for high-stakes domains. Once memory becomes shared across roles or reused across steps, governance questions become unavoidable: which items are admitted, who can read them, when should they be refreshed, and how can users inspect their provenance? Our architecture advances this perspective by making shared memory conditional and traceable.

Even though the present benchmark does not exhaust the design space of financial workflows, it provides evidence for the narrower systems principle of controlled computational activation. Memory governance is conceptually separate: it determines which intermediate information becomes reusable, whereas the routing gate determines when collaboration is activated. The experiment measures the efficiency effect of the latter and records the former, but it does not demonstrate an independent governance benefit.

The motivation for the hybrid architecture follows from a division of labor among its components. The probe minimizes routine-case token use, the escalation path preserves deliberative capacity for flagged inputs, private state contains tentative role outputs, episode-scoped shared memory supports inspectable adjudication, and structured knowledge support remains an architectural extension for evidence-intensive tasks. Their integration is potentially useful when workload difficulty is heterogeneous and operators require lower token demand plus inspectable exceptions. The numerical results support only the routing part of this argument: the system remains far less token intensive than always-on collaboration and close to direct-agent quality. The governance advantage is presently architectural because no candidate conflict occurred in the primary remainder, the few supplemental rollbacks lack a matched governance-off comparison, and the development-slice governance ablation does not separate sentence-level accuracy.

7.2. Theoretical Implications

The study offers a systems-theoretic refinement by separating two mechanisms that are often bundled in agent architectures: computational activation and state globalization. The routing results show that the availability of a collaborative subsystem need not imply its universal activation; a controller can allocate coordination using an explicit input-ambiguity proxy. The governance formulation separately treats cross-role memory as an admitted system state rather than an automatic by-product of communication. Together, these mechanisms extend prior cascade-routing, multi-agent, memory, and financial-agent work [1,2,5,6,12,13,14] toward a control-plane account in which computation, access scope, provenance, and cost are jointly managed. The ablation also refines the theoretical claim by showing that routing has direct support in the present benchmark, whereas the causal benefit of governed memory remains a proposition for harder, state-dependent tasks rather than a demonstrated accuracy effect here.

7.3. Practical Implications

For managers deploying analyst-support systems, the results suggest evaluating a staged operating policy rather than assuming a universal multi-agent workflow. Routine items can be processed by a low-cost probe, while cases flagged by a locally validated ambiguity rule can be queued for richer evidence use, collaborative adjudication, or human review. Managers can set the routing threshold against service-level targets on validation data, monitor the escalation ratio as a capacity-planning signal, and audit whether costly cases received the expected evidence and risk logs. The architecture also supports audit-oriented responsibility tracing: local hypotheses remain private until admission criteria are met, and reusable state carries provenance. These practices may reduce token-related serving expense; effects on latency, monetary cost, and human review burden remain to be measured.

7.4. Implications for Financial Decision Support

Financial decision support has several characteristics that make governed coordination potentially relevant. First, evidence can become stale quickly. Second, different evidence sources may disagree. Third, analysts often want to distinguish strong conclusions from tentative hypotheses. A layered memory architecture offers one plausible response because it separates local working context from globally reusable state. Probe-first routing may also be useful when analyst pipelines contain many routine triage tasks, although the present study does not measure real workflow prevalence or economic cost.

The proposed design should therefore be understood as an architectural template to be tested on broader financial workflows, not as direct evidence on those workflows themselves. Tasks such as disclosure analysis, event interpretation, analyst assistance, and evidence-backed report drafting may require some combination of local reasoning, shared intermediate state, retrieval support, and auditable routing, but the current study does not evaluate them. What it shows directly is that the routing ingredient produces measurable token savings in a controlled benchmark setting; the value of persistent governed memory in those broader workflows remains untested.

7.5. What the Current Results Do Not Yet Show

The present paper is intentionally conservative about its empirical scope. We do not claim that sentence-level benchmark evaluation captures all aspects of financial intelligence. The development and agreement-shifted slices are ordered and strongly label-skewed; the class-complete disjoint remainder mitigates but does not remove the limitations of a single benchmark. The evaluation also uses one backbone model and one local serving stack. It does not yet include richer tool-use tasks, longitudinal market periods, or larger document-grounded reasoning workflows, nor does it quantify governance outcomes such as stale-memory contamination, contradiction resolution, rollback frequency, or citation faithfulness under adversarial retrieval.

These omissions define the contribution’s boundary. The present results show that rule-based on-demand coordination reduces token use relative to the implemented always-on baseline in a controlled financial classification setting under one disjoint remainder, three agreement-shifted supplemental slices, one backbone, and one serving stack. They do not establish superiority across broader financial tasks, alternative backbones, or different deployment environments.

7.6. Position Relative to 2026 Financial-Agent Directions

The 2026 financial-agent research direction is increasingly defined by long-horizon workflows, tool-use trajectories, point-in-time data discipline, and governance of autonomous behavior rather than by isolated prompt performance alone [11,15]. The present study does not yet evaluate that full agenda. Its contribution is narrower: it isolates one control-plane mechanism—ambiguity-triggered routing with governed shared-state support—and validates its cost behavior on a controlled financial sentiment slice. This makes the paper a stepping stone toward the broader direction rather than a replacement for workflow-level financial-agent benchmarks. The next empirical step should therefore test whether the same controller maintains its cost–quality advantage when the escalation path must use documents, tools, temporal evidence, and human-review checkpoints.

7.7. Threats to Validity

We identify eight major threats to validity.

7.7.1. Benchmark Simplicity

Sentence-level classification is simpler than full analyst workflows. As a result, the observed high short-circuit rate may be specific to this benchmark family. The supplemental agreement-split checks show similar cost behavior under lower annotation agreement, but their ordered, label-skewed, non-independent slices provide only limited evidence beyond the all-agree data.

7.7.2. Single-Backbone Dependence

All methods use the same local backbone model. This is a strength for controlled comparison, but it means that the absolute performance and routing pattern may differ with other models.

7.7.3. Post Hoc, Single-Run Remainder Evaluation

The 2064-record remainder is disjoint from the original development slice but was not preregistered, and each method was executed once with temperature-zero decoding. Paired item-level tests describe this benchmark realization; they do not quantify variation across model seeds, serving stacks, or repeated stochastic runs. The separately executed direct and proposed calls disagree on seven short-circuit predictions but on no escalated prediction, so the paired differences do not identify a benefit from the escalation branch.

7.7.4. Development-Derived Routing Rule

The lexical ambiguity components and the primary $\tau =1$ operating point are hand-engineered development choices rather than calibrated or learned uncertainty estimates. Holding them fixed for the subsequent remainder run prevents per-item adaptation, but it does not remove benchmark-specific rule-design bias or establish transfer to another corpus.

7.7.5. Limited Retrieval Condition

The retrieval control uses four fixed demonstration snippets and lexical overlap with top-$k=3$. A realistic corpus, learned retriever, or task-specific evidence base could behave differently. Our current conclusion is therefore about this minimal instantiated control, not about retrieval in general.

7.7.6. Token-Only Resource Accounting

Resource use is measured from API-reported prompt and completion tokens. We do not measure wall-clock latency, GPU memory, energy, throughput, or monetary cost, and a different serving stack could change the operational trade-off even when token counts are similar.

7.7.7. Limited Governance Validation

All role agents agreed on the 149 escalated remainder cases, so the conflict-rollback branch was not activated in the primary comparison. The agreement-split checks record one rollback per run, but they lack matched governance-off controls and process-level reliability outcomes. The experiment therefore cannot establish whether admission filtering reduces contamination, and it does not test freshness decay, cross-case persistence, or recovery from stale state.

7.7.8. No Claim of Autonomous Finance Execution

The system is a decision-support mechanism, not an autonomous trading agent. Real-world deployment would require additional controls, data governance, and human review loops.

7.8. Practical Deployment Considerations

Despite the limitations above, several practical lessons emerge from the present benchmark setting.

• Cheap-first routing is a candidate policy when routine cases dominate. If application-specific validation confirms many routine cases and acceptable error behavior, selective escalation can reduce token use.
• State should carry provenance and scope. The architecture distinguishes local context from reusable state, although the reliability benefit of this distinction remains a future empirical question.
• Logs are part of the product. In regulated or analyst-facing settings, trajectory and risk logs are not optional diagnostics; they are part of operational accountability.
• Coordination policy should be evaluated alongside new modules. Simply attaching retrieval or collaboration to every case may increase complexity and token use without improving outcomes in settings like the one studied here.

One way to summarize this deployment intuition for a single resource measure is through a budget-feasibility constraint,

$${\rho }_{\mathrm{esc}}{C}_{\mathrm{escalate}}+(1-{\rho }_{\mathrm{esc}})C_{\mathrm{direct}}\le B_{\mathrm{ops}},$$

(9)

Equation (9) expresses the token-budget constraint, where $B_{\mathrm{ops}}$ is an operational budget in the same unit as $C_{\mathrm{direct}}$ and $C_{\mathrm{escalate}}$ (tokens per case in the present study). Latency, throughput, energy, and monetary limits should be represented as separate constraints unless an explicit conversion is defined. The governed controller is attractive when it keeps the relevant constraint below budget while preserving the required quality level.

Figure 8 summarizes the proposed deployment-time monitoring and approval loop.

Figure 8. Deployment-time governance loop. Operators monitor quality, cost, and risk signals, then update routing thresholds, freshness controls, or memory policies only through a versioned validation and approval process.

7.9. Roadmap for Next-Stage Evaluation

The current results naturally suggest a broader research agenda with testable milestones. First, a multi-document event-reasoning study should measure whether governed admission lowers stale-memory and contradiction rates under controlled temporal drift. Second, a report-level question-answering study should cross backbone models and retrieval policies to compare the present rule-based ambiguity score with calibrated predictive uncertainty and learned routing, measuring escalation precision and the cost–quality frontier. Third, a prospective analyst-assistance study should introduce human-review checkpoints and measure provenance coverage, override frequency, latency, and decision usefulness. Each study should preregister routing and admission parameters, include component-level governance ablations, and report both predictive and process-level outcomes. These directions provide a theoretical test of state-governance mechanisms and a practical test of whether the architecture remains useful under realistic evidence, workload, and accountability constraints.

8. Conclusions

This paper presented a governed hierarchical memory architecture for cost-aware multi-agent financial sentiment decision support. The core idea is that collaboration should be available, but not always active. On the class-complete 2064-record all-agree remainder disjoint from development, the proposed system achieves 0.9453 accuracy and 0.9364 macro-F1, nearly matching the direct baseline while using 63.57% fewer tokens than always-on collaboration and 31.05% more than direct inference. The earlier 200-record development slice shows 71.26% savings relative to always-on collaboration but is highly label-skewed and is used primarily for trace and ablation analysis. Across the remainder, 1915 cases short circuit and 149 escalate. No candidate conflict or rollback occurs in those escalations. The ablation results therefore narrow the claim: routing reduces token usage relative to always-on collaboration under the evaluated protocol, whereas an independent reliability or accuracy benefit from governance is not demonstrated. Escalation also changes none of the 149 final labels relative to the separately executed direct baseline, so this run does not demonstrate a predictive benefit from escalation itself.

The broader implication is systems oriented but bounded. In benchmarked financial decision-support settings, capability should not be measured only by whether a system can collaborate, retrieve, or remember. It should also be measured by whether those resources are activated under explicit control, whether shared-state admission is inspectable, and whether execution paths remain auditable. The present study therefore offers its strongest evidence for cost-aware ambiguity-triggered routing under the evaluated protocol. Governed shared memory should be viewed as a motivated architectural primitive whose broader empirical benefits still require follow-up validation on harder financial workflows.

Future work will test that primitive through three concrete extensions: temporally ordered multi-document tasks that expose stale-state contamination, cross-model routing-calibration experiments that quantify threshold transfer, and analyst-in-the-loop studies that measure provenance use and override behavior. These studies will determine whether governed admission improves reliability beyond the routing-driven cost effect observed here and whether the same control architecture remains operationally beneficial in practical financial workflows.