Learning to Route LLMs from Implicit Cost-Performance Preferences via Meta-Learning

1 Introduction

The rapid evolution of Large Language Models (LLMs) like GPT series [OpenAI, 2025] marks a significant breakthrough in artificial intelligence. These models excel at a wide array of natural language processing tasks, including complex reasoning and sophisticated problem-solving [Bubeck et al., 2023; Wei et al., 2022]. However, their immense power comes at a cost. The substantial computational and memory requirements of these state-of-the-art LLMs necessitate cloud-based deployment and expensive API access. In response to these challenges, a new class of smaller and more efficient LLMs has emerged [Touvron et al., 2023; Abdin et al., 2024]. These models are specifically designed to operate on edge devices such as personal computers. This new paradigm offers compelling advantages, including lowcost deployment, reduced latency, and enhanced data privacy.

∗Corresponding author.

However, it also introduces a critical trade-off: while constantly improving, the performance of these smaller models still lags behind the large LLMs [Ding et al., 2024].

To balance performance and cost, a common and effective strategy is to employ a hybrid system that balances the use of large and powerful models with smaller and more costeffective ones. Some approaches employ a cascade method which sequentially queries different LLMs until a reliable response is found [Chen et al., 2023; Aggarwal et al., 2023]. However, this usually needs to query multiple times and leads to high latency. A more promising solution is to use routing methods, which direct each query to a single and optimal LLM. Similar to a small model, the router can be deployed on edge devices. It can route simple queries to a local small LLM and only use an API call for difficult queries. This strategy provides a flexible way to maximize LLM power for various budgets and quality needs.

Existing research has explored various methods for routing queries. [Ding et al., 2024] used a router that assigns queries to a small or large model based on the predicted query difficulty and the desired quality level. [Ong et al., 2025] proposed several efficient router models and developed a training framework that leverages human preference data. [Feng et al., 2025] introduced a graph-based framework that utilized contextual information among tasks, queries, and LLMs to improve selection. However, a significant limitation of existing approaches is their reliance on manually configured parameters to strike a balance between performance and cost, as shown in Figure 1(a). Moreover, some advanced methods like [Feng et al., 2025] that attempted to learn these trade-offs require retraining a new model for each distinct user preference, which is both inefficient and computationally expensive.

To address these limitations, we introduce a perceptive LLM routing paradigm. As shown in Figure 1(b), the router learns users' implicit preferences through interaction. However, realizing this paradigm presents two core challenges: (a) Feedback Collection: How to collect user feedback unobtrusively while ensuring it fully reflects users' preferences? (b) Preference Integration: How to infer preferences from this feedback and incorporate them into routing decisions?

In this paper, we propose MetaRouter, an end-to-end metalearning framework for preference-aware LLM routing. We formulate the routing decision as a contextual bandit problem and treat distinct preferences as different tasks. During the meta-training phase, we train the router across diverse preference profiles to enable rapid adaptation. Specifically, our method initiates an adaptation phase where users provide pairwise comparisons of LLM responses. From this comparative feedback, we infer a latent preference representation that captures their cost-performance trade-offs. This representation is combined with users' query as input for the routing policy, allowing the system to intelligently select the optimal model for each query. By conditioning decisions on both the queries and learned preferences, our approach offers a highly personalized experience. Overall, our contributions include:

• Novel Paradigm for LLM Routing. We introduce perceptive LLM routing, a novel paradigm that goes beyond traditional manual configurations or model retraining. Our approach learns users' implicit preferences for cost-performance trade-offs through interaction, enabling the system to adaptively select the most suitable LLM for each query based on individual user needs.
• Meta-Learning Framework for Preference-Awareness. We introduce MetaRouter, a meta-learning-based approach that solves the preference-aware routing problem. To our knowledge, this is the first work to build LLM router based on meta-learning, providing insights into advancing more intelligent LLM systems.
• Comprehensive Evaluation. We validate MetaRouter on both in-distribution and out-of-distribution datasets. The results show that our method outperforms strong baselines across multiple performance metrics. Experiments also show its efficiency in learning user preferences, robustness to changes in the routable LLMs, and scalability to multi-model routing.

2 RelatedWork

Hybrid LLM. To mitigate the expenses of using LLMs, an effective strategy is to implement a hybrid system that balances the use of large and small models. Early cascade methods [Chen et al., 2023; Aggarwal et al., 2023] query models sequentially from cheapest to most expensive, but this can introduce significant latency. In contrast, routing methods [Ding et al., 2024; Ong et al., 2025; Feng et al., 2025] provide a more promising solution by directly routing queries to the most suitable model. For instance, [Ding et al., 2024] used a router to assign queries based on predicted difficulty and desired quality. [Ong et al., 2025] proposed several efficient router models and developed a training framework leveraging human preference data to enhance performance. [Feng et al., 2025] introduced GraphRouter, a framework that utilized contextual information between tasks, queries, and LLMs to improve LLM selection. Despite these advances, a significant limitation of existing approaches is their reliance on manually configured parameters to balance performance and cost, which is not userfriendly. Moreover, solutions like GraphRouter [Feng et al., 2025] require retraining a new model for each distinct user preference, which is both inefficient and computationally expensive. In this work, we introduce a perceptive LLM routing paradigm to learn users' preferences.

Meta Learning for Bandits. Meta-learning represents a paradigm that enables the model to learn a learning strategy itself. Instead of training a model to master a single task, meta-learning algorithms are trained on a distribution of tasks. Applying this principle to reinforcement learning gives rise to Meta-Reinforcement Learning (Meta-RL), which addresses poor generalization in traditional RL. Meta-RL aims to learn policies that can adapt to new tasks with minimal data. While extensively studied in general RL settings [Beck et al., 2023], meta-learning in the bandit framework remains less explored. Prior work has investigated meta-learning for adversarial bandit feedback [Khodak et al., 2023], learning policies in Bayesian bandits [Boutilier et al., 2020], and developing exploration strategies [Sharaf and Daum´e, 2021]. However, these methods are not applicable to our problem due to different settings. In this work, we frame the preference-aware LLM routing problem from a meta-learning perspective and propose an algorithm that learns a routing policy capable of quickly adapting to users' preferences.

3 ProblemFormulation

3.1 LLMRouting

We use X and O to denote the user query space and the LLM answer space, respectively. Let M = {M1,M2, . . . ,MK} represent a set of K candidate LLMs available for routing. While our proposed framework supports routing among multiple models (as validated in Section 5.4), we focus our problem formulation on the most common binary scenario (K = 2) for clarity and comparativity [Ding et al., 2024; Ong et al., 2025]. Specifically, we consider two distinct models: a large LLM, denoted as L : X → O, and a small LLM, denoted as S : X → O. Large models refer to state-ofthe-art models such as the latest GPT series [OpenAI, 2025], which are often accessed via APIs. These models offer superior performance but typically incur higher latency and monetary costs. Conversely, small models refer to lightweight models with fewer parameters that can be deployed locally, such as the Phi family [Abdin et al., 2024]. They have lower costs and weaker performance, but can achieve performance close to that of large models on many simple tasks.

LLM routing can be modeled as a sequential decisionmaking problem, which can be addressed using a contextual bandit framework. Specifically, at timestep t, a routing policy π observes a state (query xt) and selects an action at ∈ {S, L}, corresponding to the choice of model. To avoid ambiguity with "context" as used in task inference methods (introduced in the next subsection), we exclusively use the term "state" to refer to the contextual information in the bandit formulation. The reward for routing query x to model a is denoted by R(x, a), a function that depends on user utility. The performance of the routing policy can be measured by:

Model selection often involves a trade-off between performance and cost, and users have different preferences for the trade-off. To capture this, we define a general score function s(o) to represent the user utility of an LLM-generated response o. Crucially, our framework is agnostic to the specific form of s(o). This function constructs the reward that guides the policy's learning, as detailed in the next section.

User utility depends on both performance and cost of response o. Specifically, we use q(o) to represent the performance of a response o, obtainable through evaluation methods such as BART score [Ding et al., 2024] or a LLM judge [Ong et al., 2025]. Concurrently, we use p(o) to denote the inference cost of o, which is based on the token count and price. During the meta-training phase (detailed in Section 4.3), we can generate a diverse set of synthetic tasks (i.e., simulated user preferences) by varying the preference parameters (e.g., trade-off weights) inherent to the definition of s(o). For example, the most common form is s(o) = w · q(o) - (1 - w) · p(o) [Feng et al., 2025; Zhang et al., 2025a]. Note that to reduce the influence of their scales, both p(o) and q(o) are normalized.

3.2 Few-shot Preference Learning

Current methods [Ding et al., 2024; Ong et al., 2025; Zhang et al., 2025a] require users to manually configure parameters to adjust their preferences for cost and performance. However, this paradigm is unintuitive and presents usability challenges. Primarily, users often do not know the actual impact of an abstract parameter. Furthermore, this paradigm assumes that users have a clear understanding of the optimal parameter for their specific needs. Consequently, this approach can lead to suboptimal outcomes for users. In this work, we propose a method to infer user preferences from their feedback.

Motivated by the success of task inference methods in Meta-RL [Beck et al., 2023; Rakelly et al., 2019], we formulate different preferences as distinct tasks and aim to identify the "task" by collecting users' preference contexts. However, unlike standard Meta-RL, which leverages continuous environmental interactions (states, actions, and rewards) to infer tasks, the router cannot rely on constant user interaction, because collecting persistent preference feedback would severely degrade the user experience. Consequently, we decouple the inputs to the task inference method from the outputs of the policy. The task inference method is conditioned only on preference contexts collected during a preliminary adaptation process. In this process, we return responses from both models for a query and require the user to choose the better one by considering prices and performance. This feedback constitutes a preference context c. For example, if the user feels that the small model S is better for query x, then c = (x, S ≻ L). The collected contexts are denoted by c1:N .

Regarding the task inference, we represent each task T , corresponding to a unique preference profile, with a d-dimensional latent task variable z ∈ Z. The policy πθ(a|x, z), parameterized by θ, is conditioned on the task variable z, enabling end-to-end learning of the representation z alongside the policy, which aims to differentiate between task specifications. Additionally, we introduce an inference network (context encoder) Eϕ(z|c1:N), parameterized by ϕ, to infer the task variable z from preference contexts c1:N . The policy's objective is to maximize the expected reward:

In this case, our problem presents several challenges. First, it is hard to capture implicitly diverse user preferences through explicit tasks. Second, acquiring preference contexts from users' limited feedback results in a challenging datascarce learning environment. Finally, it is difficult to learn an effective policy for a contextual bandit problem, which is only one-step RL. We will address them in the next section.

4 Methodology

As shown in Figure 2, MetaRouter comprises two core components: a context encoder Eϕ and a policy network πθ. The context encoder Eϕ collects users' preference contexts during an initial adaptation phase to infer the latent task variable z. Subsequently, each query will be input into the policy network πθ together with z for intelligent routing. The following subsections will detail each component and describe how they are trained jointly through meta-training.

4.1 Context Encoder

To adapt to diverse user preferences, our router employs a context encoder Eϕ(z|c1:N). This network infers a latent context vector z which encapsulates users' preference information. This inference is conditioned on a collection of feedback contexts c1:N gathered during an adaptation phase.

A key challenge in personalization is designing a feedback mechanism that is both informative for the router and unobtrusive for the user. To achieve this, we employ a lightweight yet effective feedback system based on pairwise comparisons. During the adaptation process, the system presents the user with responses from both models. The user simply chooses the preferred one, considering both performance and price. This feedback constitutes a context c. This approach is cognitively less demanding than asking for absolute scores and provides a direct signal of the user's latent trade-offs.

While the feedback contexts c1:N are collected sequentially, we assume the underlying user preference profile remains stationary during adaptation. Therefore, the final representation z must be independent of the arbitrary order in which feedback is received. To satisfy this property, we formulate Eϕ(z|c1:N) using a permutation-invariant function:

where the function f is a neural network which outputs a ddimensional vector. The parameters of Eϕ are learned during the meta-training phase and remain fixed during inference. This deterministic task variable z offers stable and clear guidance to the policy network.

4.2 Routing Policy

Optimization Objective

For the routing policy π, we employ the policy gradient (PG) method for optimization. Recall that we model the LLM routing problem as a contextual bandit, which is a one-step RL problem. At each step, the policy observes a state (the query x) and makes a decision (selects a model a) to maximize an immediate reward. Given this "one-step" nature, PG is sufficient because it does not need to account for long-term consequences or a sequence of states.

However, standard PG methods can suffer from premature convergence, where the policy becomes deterministic too quickly, failing to sufficiently explore the capabilities of different LLMs. To mitigate this and encourage exploration, we incorporate an entropy regularization term into the objective function. The overall objective is maximizing the expected reward augmented by the entropy of the policy:

where H(π(·|x, z)) is the entropy of the policy distribution, and β is a hyperparameter controlling regularization. This ensures the router maintains stochasticity during early training, preventing collapse to a trivial solution (e.g., always selecting the largest model).

Reward Design

To ensure scalability to multi-model scenarios and stabilize the training process, we adopt a baseline subtraction technique. Specifically, we define the reward as the deviation of the selected model's utility s(oa) from the average utility of all candidate models for the given query x. Furthermore, to normalize the reward scale and mitigate the impact of outliers, we apply a hyperbolic tangent function. The formulated reward function is:

where ¯ s(x) = 1 |A| ∑a′∈A s(oa′) represents the average utility of the candidate models, and λ is a scaling factor controlling the sensitivity of the reward. This formulation encourages the policy to select models that perform above the average, providing a robust signal for training.

Network Architecture

Conventional task inference approaches typically rely on concatenating the observation with the latent task variable. However, this strategy is suboptimal in our routing problem due to the large dimensionality disparity between the dense query embedding (e.g., 768 dimensions) and the compact task variable z (e.g., 10 dimensions). Such direct concatenation risks overshadowing the information in z. Furthermore, simple concatenation provides only implicit interaction, limiting the ability of z to explicitly modulate the query representation. To overcome these limitations, we introduce a Gated Residual Mechanism, as illustrated in the right component of Figure 2 and detailed in Supplementary Material.

Our architecture processes the inputs through two parallel branches. Specifically, we utilize an observation encoder (parameterized as an MLP) to project the query embedding into a feature representation hobs. In parallel, the latent variable z is processed by a gating network to produce a modulation vector g. This process is formally defined as:

where MLPgate denotes a multi-layer perceptron projecting z to the same dimension as hobs, and the tanh activation constrains the gate values to the range [-1, 1], allowing for both feature suppression and enhancement. Crucially, instead of simple multiplication, we employ a residual connection to stabilize the training:

where ⊙ denotes the Hadamard product. This formulation allows the user preference z to selectively enhance (positive g) or suppress (negative g) specific dimensions of the query while preserving the original query information flow. Finally, hmod is fed into the MLP to output the routing probabilities.

Algorithm 1 Meta-training

Input: Batch of tasks T = {Ti}i=1...T

Parameter: Learning rates α1, α2, Noise scale σ, Noise probability pnoise

Output: πθ, Eϕ

• 1: for iteration in training iterations do
• 2: Sample a batch of training tasks Ttrain.
• 3: for each T i ∈ Ttrain do
• 4: Sample contexts ci1:N ∼ Sc(X) and batch of queries Bi ∼X.
• 5: ˜Bi ← {x + bx · ϵ | x ∈ Bi }, where bx ∼ Bernoulli(pnoise) and ϵ ∼ N(0, σ2 I).
• 6: Sample z ∼ Eϕ(z|ci1:N ).
• 7: Calculate objective: J iθ = Jθ( ˜Bi , z).
• 8: end for
• 9: ϕ←ϕ+α1∇ϕ ∑i J iθ
• 10: θ ← θ +α2∇θ ∑i J iθ
• 11: end for

4.3 Meta-training

The central goal of meta-training is to equip MetaRouter with the ability to rapidly adapt to diverse user preferences from minimal feedback. This is achieved by training the context encoder Eϕ and the routing policy πθ across a wide distribution of simulated tasks, where each task represents a unique user preference profile, as detailed in Algorithm 1.

In each training iteration, we uniformly sample a batch of tasks Ttrain (line 2). For each sampled task T i , we generate a set of preference contexts ci1:N and a batch of queries Bi (line 4). The contexts are derived by sampler Sc which applies the specific task's scoring function to LLM outputs, simulating the pairwise feedback we would get from a real user with that preference profile.

To enhance the router's robustness against input variations, we employ a noise injection strategy (line 5). Formally, for each query x in the batch Bi , we independently sample a binary mask bx ∼ Bernoulli(pnoise). The perturbed query batch ˜Bi is constructed as:

where ϵ ∼ N (0, σ2 I) represents distinct Gaussian noise sampled for each query. Note that here x refers to the embedding vector of the query (encoded by the embedding model). This acts as implicit data augmentation to smooth the decision boundary, preventing overfitting in data-scarce scenarios and improves generalization to unseen queries. The inference network Eϕ encodes the contexts into a latent task variable z (line 6), which conditions the policy πθ. The policy then processes the batch ˜Bi to compute the routing objective (line 7). Finally, the accumulated gradients are used to update the parameters of both networks (lines 9-10). The policy is updated to maximize routing performance, while the inference network is simultaneously updated by backpropagating the policy objective through the entire computational graph. This step trains Eϕ to produce latent variables z that are maximally informative for the policy, thereby directly linking the quality of the inference to the final routing performance.

5 Experiments

5.1 Experiment Setup

Datasets. We evaluate our method on three tasks: hybrid question answering (QA), code generation, and mathematical reasoning. For each task, we use one dataset to assess in-distribution (ID) performance and another to test out-ofdistribution (OOD) performance: RouteLLM [Ong et al., 2025] and AlpacaEval [Li et al., 2023] for Hybrid QA; Magicoder [Wei et al., 2024] and FullStackBench [Liu et al., 2024] for code generation; and MATH [Hendrycks et al., 2021] and Omni-MATH [Gao et al., 2024] for mathematical reasoning. For efficiency and due to the large size of the original dataset, we primarily selected difficult queries where small models are less likely to perform as well as large models. The relevant statistics are summarized in Supplementary Material.

Candidate LLM. For Hybrid QA, as the original dataset already provides responses from gpt-4-1106-preview [OpenAI et al., 2023] and Mixtral 8x7B [Jiang et al., 2024], we directly use them respectively as the large model and the small model. For other datasets, we use DeepSeek-v3 [DeepSeekAI et al., 2025] as the large model and Qwen2.5-1.5B [Yang et al., 2024] as the small model. Given that LLM judges have shown a high correlation with human judgment [Dubois et al., 2023], we use the widely-adopted LLM judge to measure the response quality [Ong et al., 2025]. We also test another quality metric BART score [Yuan et al., 2021] in Section 5.5. Pricing information for the open-source models is referenced from TogetherAI [Together AI, 2025].

Baselines. We compare MetaRouter with the following strong baselines: GraphRouter [Feng et al., 2025], which routes queries via a graph framework requiring separate training for different preferences; Avengers-Pro [Zhang et al., 2025a; 2025b], which routes based on embedding-based clustering and a cluster-wise weighted score; and two methods from [Ong et al., 2025], the training-free Similarity-weighted (SW) ranking and the recommended method Matrix Factorization, both using thresholds to control trade-offs. We also include Oracle to demonstrate the performance upper bound.

Implementation Details. Following common designs [Feng et al., 2025; Zhang et al., 2025a], we instantiate the score function as s(o) = w · q(o) - (1 - w) · p(o), where q(o) and p(o) denote the normalized quality and price, respectively. We also test more complex score function in Section 5.5. For all routers, we set ten different levels of preference for balancing performance and costs. We adopt all-mpnet-base-v2 [Song et al., 2020] as the embedding model to encode queries. Network architectures and other details are provided in the Supplementary Material.

Metrics. We use two standard metrics in multi-objective optimization: Hypervolume (HV) [Zitzler and Thiele, 1999] for overall quality, and Inverted Generational Distance (IGD) [Coello and Sierra, 2004] for convergence, using the Oracle's solution as the true Pareto front. To complement these geometric metrics, we report the Area Under the CostPerformance Curve (AUC), which quantifies the router's global efficiency and robustness across the cost spectrum.

5.2 Main Results

Table 1 displays the in-distribution (ID) performance of all methods. As shown, MetaRouter consistently outperforms the baseline methods across all metrics on all ID datasets. For example, it improves the HV score by approximately 8.8% and reduces the IGD score by 40.6% compared to the second-best method on the RouteLLM dataset. Furthermore, MetaRouter achieves the highest AUC scores across all tasks. This suggests that MetaRouter is highly effective when the test data distribution matches the training distribution.

Table 2 evaluates out-of-distribution (OOD) generalization. MetaRouter demonstrates strong generalization capabilities, achieving the best performance across all metrics on AlpacaEval and FullStackBench. On Omni-MATH, while Matrix factorization achieves slightly better HV and IGD scores, MetaRouter outperforms all baselines in terms of AUC. Overall, MetaRouter maintains robust performance against baselines. We also observed a noticeable gap between the oracle and all methods in Omni-MATH and FullStackBench, which can be attributed to the limited size of the training dataset.

Figure 3 provides a visual example of the router's performance on both ID and OOD datasets for the Hybrid QA task. Other figures are available in the Supplementary Material.

5.3 Context Analysis

We need to collect contexts to infer preferences in the adaptation process. Obviously, the quantity of context significantly impacts performance. If many contexts are required for accurate inference, this method will impose a significant burden on the user, which is unacceptable. In this section, we want to answer the following question: How many preference contexts c does the context encoder need to infer a reliable z?

We conducted experiments on the RouteLLM dataset. To intuitively measure the impact of context quantity, we defined average task accuracy (ATA). This metric is the average accuracy computed over all test samples from all tasks. A prediction is deemed correct if our router's output matches the output from the oracle. Formally, ATA is defined as:

where Dtest is the number of samples in the test set and T is the total number of tasks.

As shown in Figure 4, the experimental results indicate that only a few (around 6) contexts are needed to achieve strong performance. After that, accuracy continues to rise at a slower pace and appears to plateau around 0.86 after 18 contexts. MetaRouter reaches a saturation point where it has sufficient information for optimal performance.

5.4 Generalization and Scalability

Generalization to New Model Pair. To evaluate generalization, we tested the router on AlpacaEval using a new model pair (Claude 3 Opus [Anthropic, 2024] and Llama 3 8B [AI@Meta, 2024]) instead of the original training pair (GPT-4 [OpenAI et al., 2023] and Mixtral-8x7B [Jiang et al., 2024]), without retraining. As shown in Figure 5 (left), MetaRouter consistently outperforms baselines, demonstrating strong generalization capabilities.

Scalability to Multi-Model Routing. We further extended our framework to a multi-model setting involving five candidates on the RouteLLM dataset: Mixtral-8x7B, Llama 3 8B, Yi 34B [AI et al., 2024], Llama 3 70B, and GPT-4. To adapt to this scenario, we maintain the pairwise comparison mechanism during the preference adaptation phase by sampling response pairs from the candidate pool. Crucially, our reward formulation (Eq. (5)) naturally scales to this setting, requiring no architectural changes other than adjusting the policy's output dimension to 5. Note that baselines strictly limited to binary settings (SW Ranking and Matrix Factorization) were excluded. Figure 5 (right) shows that MetaRouter significantly outperforms other baselines, indicating that our formulation scales naturally to larger action spaces.

5.5 Sensitivity Analysis

Utility Functions. To assess adaptability to complex user preferences, we employed the non-linear Cobb-Douglas utility function [Cobb and Douglas, 1928], defined as s(o) = q(o)1-w · p(o)-w . We exclude threshold-based baselines as they do not explicitly optimize utility. Figure 6 (Left) shows that MetaRouter maintains its performance advantage, confirming its robustness to diverse preference structures.

Figure 6: Sensitivity Analysis. (Left) Performance comparison under the non-linear Cobb-Douglas utility function. MetaRouter (red) remains closest to the Oracle (blue). (Right) Evaluation using transformed BART scores as the quality metric. The proposed method consistently outperforms baselines across varying cost constraints.

Quality Metric for Responses. We substituted the LLM judge with the BART score [Yuan et al., 2021]. To align this metric with our utility formulation, we transformed the original log-probability scores into the [0, 1] range using an exponential function(eBART Score ). Figure 6 (Right) confirms that MetaRouter consistently outperforms the baselines, regardless of the metric employed.

5.6 Ablation Study

We conducted ablation studies to validate the contribution of Entropy Regularization (ER), the tanh operation in reward design, the Gated Residual Mechanism (GRM), and Noise Injection (NI). The proposed MetaRouter yields the best performance with an HV of 0.8437. The removal of ER and NI decreases the HV to 0.8236 and 0.8233, respectively. Furthermore, the IGD metric worsens from 0.0801 to 0.0935 when GRM is excluded (replacing it with a direct concatenation of z and x). This consistent performance drop across different metrics confirms the effectiveness of our design. Please refer to the Supplementary Material for the complete table.

6 Conclusion

In this paper, we study the problem of balancing cost and performance in LLM applications. To this end, we introduce perceptive LLM routing, a novel user-centric paradigm. To realize this paradigm, we present MetaRouter which is the first framework to leverage meta-learning for LLM routing. Experimental results demonstrate that MetaRouter significantly outperforms strong baselines on both in-distribution and outof-distribution tasks. Furthermore, it exhibits strong generalization to unseen model pairs and scalability to multi-model routing. Future work will aim to expand the scope of user preferences to include other critical dimensions such as latency and privacy.

Acknowledgements

This work is supported by National Natural Science Foundation of China (Project 62502412), Guangdong Province (Project 2024QN11X097), and HKUST-HKUST(GZ) Crosscampus Collaborative Research Scheme under the "1+1+1" Joint Funding Program (G081).