Soft-clamped Momentum Expert Bias Updates

• The paper introduces SMEBU as a novel method that employs soft-clamped momentum to update expert biases and improve routing decisions.
• SMEBU integrates static descriptions with dynamic signals, such as lightweight ACK feedback, to enhance precision in multi-agent collaboration.
• The approach preserves privacy by preventing raw knowledge base exposure and leverages semantic caching to mitigate computational latency.

Below is a self‐contained technical narrative of the Knowledge Base‐Aware (KBA) Orchestration framework as introduced in “Knowledge Base‐Aware Orchestration: A Dynamic, Privacy‐Preserving Method for Multi‐Agent Systems.” All mathematical notation is in LaTeX; bullet lists are only used sparingly for readability.

1. Formal Problem Setup and Notation Let A={a₁,…,aₙ} be the set of n agents. Each agent aᵢ maintains a private knowledge base Kᵢ (e.g. a collection of documents, policies or tool‐accessible resources). A user’s request or task is denoted by T (or Q in the algorithms) and is represented by an embedding e(T)∈ℝᵈ generated via a fixed encoder. In addition each agent publishes a static, textual description Dᵢ, which the orchestrator can also embed as dᵢ=e(Dᵢ). The goal is to design an orchestrator ORCH that, given T and the pool A, returns an agent aₖ∈A most likely to satisfy T while preserving each Kᵢ’s confidentiality.
2. Lightweight ACK Signals When static descriptions alone yield low confidence, ORCH dispatches T to all agents in parallel. Each agent computes a relevance score rᵢ(T) = max_{f∈Kᵢ} sim(e(T),e(f)) where sim(·,·) is cosine similarity in ℝᵈ. It then emits an acknowledgment ackᵢ(T) = { 1 if rᵢ(T) ≥ θᵢ { 0 otherwise Optionally agents can return the real‐valued rᵢ(T) (a “graded ACK”) rather than just a binary flag. Formally: ackᵢ(T) ∈{0,1} , rᵢ(T)∈[0,1], and ackᵢ(T)=1⇔rᵢ(T)≥θᵢ.
3. Shared Semantic Cache S The orchestrator maintains a cache S of capacity M entries, each entry a tuple (v_j,a_j) where v_j=e(T_j) is the embedding of a past task and a_j the agent that successfully served it. Given a new task T, ORCH first searches S for any v_j such that sim(e(T),v_j)≥σ (a hit threshold). If found, it immediately returns a_j. Otherwise it proceeds to routing and then augments the cache: S_{t+1} = { S_t ∪ {(e(T),a*)} if |S_t|<M { (S_t{oldest}) ∪ {(e(T),a*)} if |S_t|=M More compactly, letting g be the eviction‐and‐insert operator, S_{t+1} = g(S_t,{(e(T),a*)}).
4. Combined Routing Decision On a cache miss, the orchestrator computes for each agent aᵢ two scores:
   • Static score sᵢ^{stat}(T)=sim(dᵢ,e(T)),
   • Dynamic score sᵢ^{dyn}(T)=rᵢ(T) (if probing is used; else 0). These are linearly combined: sᵢ(T)=α·sᵢ^{stat}(T) + (1−α)·sᵢ^{dyn}(T), where α∈[0,1] trades off reliance on static descriptions vs. KB signals. Finally the orchestrator picks a* = argmax_{i∈[1..n]} sᵢ(T) provided s_{a*}(T)≥τ{\min}. In practice τ{\min} (and α) are chosen by cross‐validation on a held‐out routing set.
5. Privacy‐Preserving Guarantees Because each agent only returns ackᵢ(T) (and optionally rᵢ(T)), no raw KB content is exposed. To further hide even the exact value of rᵢ(T), one can employ local differential privacy by having each agent release rᵢ′(T)=rᵢ(T)+Lap(Δ/ε) where Lap(b) is Laplace noise of scale b, Δ the sensitivity of sim(·,·), and ε the privacy budget. This ensures each ack or score output satisfies ε‐DP.
6. Pseudocode of the Full KBA Workflow Below is a single‐function sketch in prose of the end‐to‐end flow:

Function RouteRequest(Q,A): 1. E←Embed(Q). 2. If ∃(v,a)∈S with sim(E,v)≥σ then return Handoff(a,Q). 3. For each aᵢ∈A compute static confidences sᵢ^{stat}=sim(dᵢ,E). 4. Let (i*,c*) be the agent and score with maximum sᵢ^{stat}. If c*≥τ (high‐confidence) then 4.1 S←g(S,{(E,a_{i*})}); return Handoff(a_{i*},Q). 5. Else (uncertain) → Dynamic Knowledge Probing: 5.1 In parallel for each aᵢ call ackᵢ, rᵢ. 5.2 Let C={aᵢ|ackᵢ=1}. 5.3 If |C|=1 let a*=the sole member; Else if |C|>1 resolve by user or highest rᵢ; Else fail “no capable agent.” 5.4 S←g(S,{(E,a*)}); return Handoff(a*,Q).

Each agent implements:

Function HandleProbeRequest(Q): 1. Check authorization. 2. If ∃v in local cache with sim(Embed(Q),v)≥σ_loc then return OK. 3. Retrieve top‐k fragments from Kᵢ; set rᵢ=max sim(Q,fragment). 4. ackᵢ=1 if rᵢ≥θᵢ else 0; cache the result; return ackᵢ (and rᵢ).

1. Experimental Setup and Quantitative Results We evaluated on a 7-agent corporate simulation (Accounting, HR, IT, Legal, Marketing, R&D, Sales), each with 20 test questions (total 140). Two orchestrators were compared:

• Description‐Driven Baseline (only static Dᵢ).
• KBA Orchestrator (static+dynamic).

Metrics: routing precision (exact match), latency, token usage. Key results:

• Baseline‐Low (Basic+Generic cards): Accuracy=43.6%, Precision=58.0%
• Baseline‐High (Detailed+Fine-tuned): Accuracy=68.6%, Precision=76.3%
• KBA‐Low: Accuracy=87.1%, Precision=91.3%
• KBA‐High: Accuracy=95.0%, Precision=95.4%

Thus ΔPrecision=Precision_{KBA‐Low}−Precision_{Baseline‐Low}=91.3−58.0=33.3 pp and ΔPrecision_{KBA‐High−Baseline‐High}=95.4−76.3=19.1 pp.

Latencies without caching: Baseline ≈100 s/query, KBA ≈570 s/query; tokens consumed were roughly 3× higher for KBA. However, semantic cache hit rates rapidly amortize the probing cost under query repetition.

2. Advantages, Limitations, and Extensions Advantages

• Adaptive routing that reflects evolving agent expertise.
• Strong privacy: only lightweight signals released, no raw KB content.
• Robust to poor or minimal static descriptions.
• Semantic cache amortizes cost in production workloads.

Limitations and Future Work

• Cold‐start cost and synchronization latency when probing many agents.
• Choice of thresholds (τ,θᵢ,σ) and α require tuning; can be automated via online learning.
• Cache invalidation in high‐dimensional embedding spaces needs careful management (sphere‐based eviction).
• Resilience against misconfigured or adversarial agents that misreport acknowledgments.
• Extending to graded or probabilistic ACKs and to fully decentralized orchestration without a single central controller.

In summary, the KBA Orchestration framework formally augments static‐description routing with dynamic, private relevance signals, managed through a semantic cache, to achieve substantially higher routing precision at only modest additional cost once caching is in place.