fusionroute-token-llm-collaboration

name	fusionroute-token-llm-collaboration
title	Token-Level LLM Collaboration via FusionRoute
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2601.05106
keywords	["Multi-Expert LLMs","Token-Level Routing","Model Collaboration","Inference Efficiency"]
description	Combine multiple specialized language models at token-level granularity without joint training or architectural compatibility. FusionRoute performs expert selection and generates complementary logits to overcome routing limitations, achieving superior cross-domain performance at inference time.

When to Use This Skill

• Combining pre-trained specialized models (math experts, code specialists, reasoning models)
• Cross-domain tasks requiring diverse expertise (reasoning, coding, instruction following)
• Inference-time optimization where gradient access to experts is unavailable
• Scenarios where model merging or joint training is infeasible or expensive

When NOT to Use This Skill

• Single-domain applications with single best-fit expert
• Token-level computation budget is critical (lightweight overhead still adds up at scale)
• Experts require synchronized updates or shared gradients
• Real-time latency constraints require minimal routing overhead

Problem Summary

Organizations possess multiple specialized models but face a core dilemma: general-purpose models are expensive, while specialized models fail outside their training distributions. Prior token-level collaboration relies solely on expert selection between fixed outputs. However, a fundamental limitation exists: pure expert-only routing cannot attain optimal value functions unless strong assumptions hold. The routing-only approach treats expert outputs as immutable, limiting policy expressiveness.

Solution: FusionRoute Dual-Function Framework

Perform simultaneous expert selection AND complementary logit generation at each token, expanding the achievable policy class beyond fixed expert outputs.

class FusionRoute:
    def __init__(self, router, expert_models, num_experts):
        self.router = router  # Learned routing network
        self.experts = expert_models
        self.num_experts = num_experts

    def forward(self, token_embedding):
        """Select expert AND generate complementary logits"""
        # Step 1: Expert selection via routing weights
        routing_weights = self.router.select_expert(token_embedding)
        expert_idx = torch.argmax(routing_weights)

        # Step 2: Get selected expert's logits
        expert_output = self.experts[expert_idx](token_embedding)

        
        
        complement_logits = .router.generate_complement(token_embedding, expert_idx)

        
        final_logits = expert_output + complement_logits
         final_logits, routing_weights