Small-Large Collaboration in Heterogeneous Systems

• Small-Large Collaboration (SLC) is a design philosophy for heterogeneous intelligence systems that combines lightweight, task-specialized small models with broad, deep reasoning large models.
• It employs coordination patterns such as routing escalation, planning-execution division, and judge-and-route collaboration across multiple domains including language, vision, and edge computing.
• Empirical studies reveal notable improvements in efficiency, accuracy, and cost reduction while also highlighting challenges like calibration, privacy protection, and system overhead.

Small-Large Collaboration (SLC) denotes a family of systems in which small models and large models work together in one system, complementing each other’s strengths rather than being treated as substitutes. In the recent literature, SLC is organized by collaboration objective—performance enhancement, cost-effectiveness, cloud-edge privacy, and trustworthiness—and by mechanism—pipeline collaboration, hybrid / routing collaboration, auxiliary / enhancement collaboration, knowledge distillation-driven collaboration, and integration / fusion collaboration (Wang et al., 14 Oct 2025, Chen et al., 12 May 2025). Across language modeling, vision-language systems, code editing, autonomous agents, cloud-edge inference, wireless communications, federated continual learning, and semantic change detection, the recurring division of labor is that small models provide compactness, low latency, local deployability, privacy-preserving local processing, or task specialization, while large models provide broad knowledge, stronger reasoning, stronger generative capacity, or semantic arbitration (Liu et al., 24 Apr 2025).

1. Conceptual scope and terminology

SLC is not a single algorithmic technique but a design philosophy for heterogeneous intelligence systems (Wang et al., 14 Oct 2025). The surveys treat collaboration as a division of labor: LLMs or other large models serve as the “brain” for deep reasoning, generalization, or broad prior knowledge, whereas SLMs or other small models serve as the front-end processor, lightweight local agent, or deployable specialist (Chen et al., 12 May 2025). The position paper on domain tasks formalizes the same idea through three information-flow families: LM-to-SM transfer, SM-to-LM transfer, and collaborative inference (Liu et al., 24 Apr 2025).

The term is also broader than a single model pair. In data synthesis, GRA uses a Generator, Reviewer, and Adjudicator committee of small LLMs to simulate a peer-review-inspired pipeline and reports that GRA-produced data matches or exceeds the quality of single large LLM outputs such as Qwen-2.5-72B-Instruct, challenging the necessity of monolithic large models for high-quality data synthesis (Gao et al., 11 Apr 2025). This suggests that, in some parts of the literature, SLC names a general principle of asymmetric capability coordination rather than only a fixed two-model architecture.

Terminology varies by domain. Language papers use SLM/LLM or SLM/LRM; wireless papers use SAM/LAM; multimodal work uses small VLM / large VLM; federated continual learning combines a frozen large foundation model with heterogeneous lightweight client models (Wang et al., 5 Feb 2026, Cui et al., 13 Dec 2025, Yang et al., 10 Aug 2025, Yu et al., 13 Aug 2025). The underlying claim is stable: neither model class is universally optimal, and collaboration is used to route the right kind of intelligence to the right stage of the workflow (Wang et al., 14 Oct 2025).

2. Canonical coordination patterns

A central SLC pattern is routing and escalation. COREA first sends the input question $x$ to the SLM, which produces reasoning $y_r$, a final answer $y_a$, and a verbalized confidence score $y_c \in [0,1]$; if $y_c \ge T$, the SLM answer is accepted, and if $y_c < T$, the original query is deferred to the LLM (Zhang et al., 4 Mar 2026). MentorCollab replaces query-level deferral with selective inference-time guidance: at randomly sampled token positions,

$B_t \sim \mathrm{Bernoulli}(\rho),$

the system probes divergences between the generator and the mentor, consults short lookahead segments, and uses a lightweight verifier to decide whether the SLM should follow the mentor or continue on its own (Wang et al., 5 Feb 2026). AgentCollab extends escalation to long-horizon agents through a self-evaluation signal $\mathrm{value}_t \in \{TRUE, FALSE\}$ and a cumulative escalation level

$$l_t = \begin{cases} l_{t-1}+1, & \text{if } \mathrm{value}_t = FALSE,\ 0, & \text{if } \mathrm{value}_t = TRUE, \end{cases}$$

so repeated stagnation yields a larger large-model budget (Gao et al., 27 Mar 2026).

A second pattern is planning by the large model, execution by the small model. In cascaded code editing, the first stage is edit sketch generation, where a large model produces a concise sketch of the intended modifications; the second stage is edit sketch application, where a smaller model merges that sketch into the original code to produce the final file (Wang et al., 21 Apr 2026). In dynamic help-seeking, the SLM and LLM remain active over a trajectory

$$H_t = \{T_0, o_0, a_0, T_1, o_1, a_1, \ldots, T_{t-1}, o_{t-1}, a_{t-1}\},$$

where the SLM learns when to ask for help, how to formulate a request, and when to stop asking, while the LLM can request context or provide relevant information (Zeng et al., 20 Apr 2026).

A third pattern is judge-and-route collaboration. KCM uses a KAN-based judgment model $y_r$0 to compute a confidence score

$y_r$1

and routes samples according to threshold $y_r$2 (Dai et al., 23 Oct 2025). Low-confidence samples are sent to the large model, the small-model confidence is injected into the prompt, and the small model is further refined by distillation from large-model outputs.

Not all SLC is reducible to discrete handoff. SSD-2 ensembles a large general-purpose diffusion LM with smaller specialized diffusion LMs by logit interpolation at each diffusion timestep over a block of tokens, exploiting bi-directional context and iterative denoising (Han et al., 2023). CE-LSLM treats KV caches as reusable semantic artifacts: a cloud LLM computes and stores context KV caches, while edge SLMs perform local decoding, reuse the cloud’s semantic context, and overlap communication with computation through layer-wise pipelined execution (Zhu et al., 20 May 2025).

3. Learning signals, calibration, and optimization

Several SLC systems learn the collaboration policy directly. The dynamic help-seeking framework trains the SLM end-to-end with online RL using a multi-objective reward that includes exact match quality, an efficiency penalty, a feedback reward when the LLM asks for contextual information, a privacy penalty when a request leaks user-private information, and a format reward for the required trajectory structure (Zeng et al., 20 Apr 2026). The setting is explicitly asymmetric: the user query is visible only to the SLM, whereas the LLM sees only the current request or context.

COREA introduces RLCC, a reinforcement learning method with an additional confidence calibration reward (Zhang et al., 4 Mar 2026). For a question-answer pair, the system samples a rollout group, estimates the empirical correctness probability $y_r$3, and rewards the verbalized confidence $y_r$4 for matching that probability. Calibration is evaluated with Expected Calibration Error (ECE),

$y_r$5

along with AUROC and Confidence Output Ratio. This makes confidence not merely a side output but the gating variable of the collaborative system.

MentorCollab shows a different optimization philosophy. MentorCollab-Free uses the generator itself as a verifier through a choice between candidate continuations, whereas MentorCollab-MLP trains a small MLP on the generator’s hidden state at the decision point, with three hidden layers of widths $y_r$6, each followed by batch normalization, ReLU, and dropout $y_r$7 (Wang et al., 5 Feb 2026). The paper’s claim is that effective collaboration does not require long mentor reasoning; short, verifier-gated segments are sufficient.

Domain-specific SLC often relies on specialized training curricula. Cascaded code editing introduces Curriculum-based Long-Context SFT (CLC SFT), splitting examples by original-code length with 4,096 tokens as the threshold, training first with an 8,192-token truncation window and then with a 16,384-token window plus synthetic multi-file instances; G-CLC SFT mixes OpenCoder SFT at a 1:1 ratio in both stages (Wang et al., 21 Apr 2026). Fed-LSCL adds Small Model Continual Fine-tuning, which regularizes both current features and generated adapter parameters against the previous task model, and One-by-One Distillation, which returns a personalized fused generator to each client (Yu et al., 13 Aug 2025). In farmland semantic change detection, hard-region co-training supervises the semantic score map only on low-confidence pixels, with default $y_r$8 and $y_r$9, rather than on the full image (Li et al., 12 May 2026).

4. Domain-specific instantiations

In software engineering, SLC exploits the asymmetry between reasoning difficulty and token volume. Cascaded code editing assigns the large model the hard phase—understanding the codebase and natural-language instruction well enough to synthesize a precise edit sketch—and assigns the small model the relatively simpler but token-heavy application phase (Wang et al., 21 Apr 2026). In reasoning-oriented language tasks, the same asymmetry appears as confidence-based deferral, sparse mentoring, self-reflection-driven escalation, or multi-turn help-seeking, depending on whether the bottleneck is calibration, local error correction, trajectory stagnation, or privacy-sensitive request formulation (Zhang et al., 4 Mar 2026, Wang et al., 5 Feb 2026, Gao et al., 27 Mar 2026, Zeng et al., 20 Apr 2026).

In multimodal personalization, SLC separates user-specific perception from general multimodal reasoning. The small VLM examines the image and registered user concepts and outputs structured cues about presence and location; the large VLM then runs a test-time reflection step that asks whether an immutable identity phrase is at the reported absolute or relative location before using the cue in final answer generation (Yang et al., 10 Aug 2025). In farmland semantic change detection, the same pattern appears in a different form: FD-Mamba learns dense change representations for boundary preservation and small-region localization, while the frozen CLIP-based CMLA branch introduces prompt-guided semantic arbitration and pseudo-change suppression (Li et al., 12 May 2026).

Cloud-edge and communications papers treat SLC as a joint compute-communication architecture. CE-LSLM lets a cloud LLM process the system prompt, generate per-layer KV caches, and distribute hierarchically pruned and dimensionally reduced caches to edge SLMs that handle user prompts, privacy-sensitive local content, and lightweight decoding (Zhu et al., 20 May 2025). LASCO and E-LASCO use a frozen LAM as a foundational channel knowledge base and small models as lightweight plugins for environment-specific CSI feedback. Their core reconstruction rule is

$y_a$0

and E-LASCO adds a learnable collaboration coefficient $y_a$1 to control the contribution of generalized and environment-specific knowledge (Cui et al., 13 Dec 2025). In LEO satellite networks, remote sensing satellites process part of the workload locally with a small model and offload the remainder to computing satellites with a large model, while a MARL-based routing layer minimizes end-to-end service delay (Guo et al., 6 May 2026).

Federated continual learning uses SLC to bridge private local adaptation and a frozen large representation model. Fed-LSCL freezes a ViT foundation model, lets each client small model learn continually from a private evolving task stream, generates LoRA-style adapter parameters from small-model features, and uploads only a parameter generator and a feature set for server-side personalized distillation (Yu et al., 13 Aug 2025). The domain-task position paper generalizes this pattern by arguing that privacy-sensitive AI should connect large and small models through controlled knowledge transfer rather than frame the problem as replacing one with the other (Liu et al., 24 Apr 2025).

5. Empirical behavior and scaling properties

Dynamic help-seeking reports a distinct scaling effect: stronger SLMs become more self-reliant, while stronger LLMs enable fewer and more informative interactions (Zeng et al., 20 Apr 2026). The same paper reports 14.5%–17.4% EM improvement over SLM CoT, 2.8%–9.9% over static interaction/tool baselines, 0.11–0.15 fewer average interaction turns than static interaction, and near-zero privacy leakage on PrivQA, with about 0.26% leakage for Qwen3-4B and about 0.08% for Qwen3-8B (Zeng et al., 20 Apr 2026). COREA reports 21.5% cost reduction on out-of-domain math datasets and 16.8% cost reduction on out-of-domain non-math datasets, with only an absolute pass@1 drop within 2% (Zhang et al., 4 Mar 2026). MentorCollab improves performance in 12 out of 15 settings, with average gains of 3.0% and up to 8.0%, while only 18.4% of output tokens are generated by the mentor on average (Wang et al., 5 Feb 2026). AgentCollab improves the accuracy-efficiency Pareto frontier of LLM agents; on DDV2 it reaches 33.9 on BrowseComp_zh with 1.36× speedup and 21.1 on HLE-math with 2.31× speedup (Gao et al., 27 Mar 2026).

In code editing, collaboration can improve both efficiency and effectiveness. On Aider, using DeepSeek-R1 as sketch generator and fine-tuned Qwen2.5-Coder 14B as applicator yields Pass@2 = 75.1, compared with 67.6 for direct DeepSeek-R1 editing, while reducing total time from 27.31h to 23.80h and cost from $y_a$25.32 (Wang et al., 21 Apr 2026). KCM reports comparable or better task accuracy with fewer large-model calls across modalities: on APD with ChatGPT backbone, large-model invocation is reduced by 67.85%; on CIFAR-100-LT it achieves 64.66 overall accuracy with LM rate 59.80%; on MSCOCO it reaches BLEU-4 36.42 with LM rate 62.32% (Dai et al., 23 Oct 2025).

Infrastructure and multimodal systems show similarly concrete gains. CE-LSLM reports TTFT 210.24 ms and total 68.58 s on XSum, and TTFT 170.03 ms and total 11.00 s on MMLU, with upload ratio 0% and transmitted data size 0 MB in the reported CE-LSLM setting (Zhu et al., 20 May 2025). LASCO and E-LASCO improve both NMSE and GCS, and in about 50% of test cases require significantly fewer training epochs to adapt than the baselines (Cui et al., 13 Dec 2025). In VLM personalization, SLC uses only

$y_a$3

for meta-training, about 40× less than Yo’LLaVA and more than 40× less than MC-LLaVA, while SLC with GPT-4o reaches 0.951 recognition and 0.979 VQA on Yo’LLaVA (Yang et al., 10 Aug 2025). In farmland semantic change detection, FD-Mamba plus CMLA achieves 97.63% F1, 96.32% IoU, and 96.35% SCD_IoU_mean on HZNU-FCD with only 6.65M trainable parameters (Li et al., 12 May 2026). Delay-aware satellite collaboration reports service-delay reduction of up to 31.85% compared with benchmarks (Guo et al., 6 May 2026).

A plausible implication is that strong SLC systems concentrate high-capacity computation on semantically critical or low-confidence regions while leaving routine processing to cheaper models. That pattern appears as sparse mentor tokens, confidence-based deferral, hard-pixel supervision, sketch-based decomposition, KV-cache reuse, and environment-specific residual correction across otherwise dissimilar domains.

6. Limitations, misconceptions, and open problems

The surveys identify system overhead, inter-model consistency, robust task allocation, evaluation complexity, and security/privacy concerns as persistent challenges (Chen et al., 12 May 2025). The objective-driven survey adds the lack of standardized end-to-end cost metrics, formal privacy guarantees, and unified safety evaluation across decoding and moderation (Wang et al., 14 Oct 2025). The domain-task position paper therefore advocates multi-objective benchmarks on real-world private datasets and applications, explicitly including utility, privacy, communication cost, computation cost, robustness, interpretability, fairness, model ownership protection, and LM query cost (Liu et al., 24 Apr 2025).

Individual systems expose recurring failure modes. COREA notes that confidence outputs are often discrete rather than smooth, causing non-smooth transitions in accuracy and cost as the threshold changes; it also reports that very small models can remain overconfident on out-of-capability problems or become underconfident late in training (Zhang et al., 4 Mar 2026). KCM identifies accuracy degradation, catastrophic forgetting, and hallucination amplification induced by small-model knowledge in prior MLP-based collaborative models, which is why it replaces the MLP collaborative model with a KAN-based one (Dai et al., 23 Oct 2025). The VLM personalization framework states that reflection mitigates but does not completely eliminate small-model hallucination, and that adapter selection is coarse because one meta-adapter is chosen per scenario (Yang et al., 10 Aug 2025).

SLC is also vulnerable to terminological drift. The paper “Analysis of a Spotify Collaboration Network for Small-World Properties” is not an empirical paper about Spotify or collaborations; it is a sample AMS $y_a$4 document and provides no support at all for Small-Large Collaboration (Bush, 12 Mar 2025). That negative case is instructive: the label “collaboration” can refer to unrelated graph or network topics unless the model hierarchy, information flow, and division of labor are explicit.

The open problems named across the literature are comparatively consistent. Future directions include more intelligent adaptive routing, deeper model fusion, multimodal and embodied extensions, better monitoring and debugging frameworks for distributed multi-model systems, stronger privacy and model-security guarantees, and benchmark realism grounded in private-domain deployment rather than only public academic datasets (Chen et al., 12 May 2025, Wang et al., 14 Oct 2025, Liu et al., 24 Apr 2025). In that sense, SLC has already become a cross-domain systems paradigm, but it remains methodologically unsettled: the field has many successful instantiations, yet no single coordination mechanism has emerged as universal.