GMTRouter: Personalized LLM Router over Multi-turn User Interactions

AI summary

Overview

• Research area: Natural Language Processing / LLM serving — specifically personalized LLM routing (choosing which model should answer a given query) using heterogeneous graph learning over multi-turn user–LLM interaction histories.
• Technical level: Advanced (requires familiarity with heterogeneous graph neural networks, graph transformers, PLM embeddings, and routing benchmarks).
• Scope: The paper defines a personalized multi-turn LLM routing task, builds a five-node-type heterogeneous interaction graph with an inductive training scheme, and evaluates it on five datasets against seven baselines. The paper states it was accepted to Findings of the Association for Computational Linguistics: EMNLP 2026.

What This Paper Is About

Most LLM routers pick a model based only on the query, ignoring who is asking — yet the paper shows that different users rank the same LLMs very differently. The authors argue that existing routers either ignore user interaction histories or fail to model multi-turn conversation structure, and that per-user preference data is usually too scarce and inconsistently formatted to train on directly. GMTRouter addresses this by turning multi-turn user–LLM interactions into a heterogeneous graph and learning to infer individual preferences from only a handful of interaction records.

Key Contributions

1. A new task framing: To the authors' knowledge, they are among the first to introduce a personalized LLM routing task based on multi-turn user interactions.
2. A heterogeneous graph framework: User–LLM interactions are modeled as a graph with five node types (user, LLM, query, response, turn), with user feedback encoded as a preference feature on response nodes so preference signals propagate across the graph.
3. Few-shot personalization via sampling: A user-conditioned graph sampling mechanism plus a lightweight inductive GNN training framework lets the model capture user preferences from limited data and adapt to unseen users at test time without retraining.
4. Empirical validation: On five datasets spanning real-world and synthetic settings, GMTRouter beats the strongest baselines by up to 0.108 absolute accuracy and 0.124 AUC.

Main Findings

• Users really do disagree about models: On ChatBot Arena, global consistency of LLM preference rankings across users (Spearman 0.524) is only 65.99% of within-user self-consistency (Spearman 0.793). Even within query-similarity clusters, the score (0.573) is only 72.28% of self-consistency, and the inter-cluster score is 0.442. The analysis uses 10 active users with at least 50 records each and 1,480 records in total.
• Consistent gains across all five datasets: GMTRouter reaches ACC/AUC of 0.778/0.843 on HUMAINE, 0.774/0.875 on ChatBot Arena, 0.784/0.859 on MT-Bench, 0.773/0.859 on GSM8K, and 0.771/0.870 on MMLU — best on all reported metrics.
• Prompt-based personalization is weak: Vanilla LLM (LLaMA-3.1-70B) and the retrieval-augmented Personalized LLM baseline lag well behind, indicating LLMs struggle to extract preference patterns directly from raw interaction data.
• Beats specialized routers and memory-based recommenders: GMTRouter outperforms GraphRouter, FrugalGPT, RouteLLM, MA-GNN, and TIGER. For comparison, GraphRouter scores 0.669/0.712 on HUMAINE and 0.771/0.869 on ChatBot Arena, while MA-GNN scores 0.679/0.739 on MT-Bench.
• New users generalize well: With 30% of users held out of training, GMTRouter (new user) scores 0.658/0.707 on HUMAINE, 0.780/0.858 on ChatBot Arena, 0.759/0.824 on MT-Bench, 0.756/0.833 on GSM8K, and 0.751/0.831 on MMLU, remaining competitive with the old-user setting.
• Gains are smaller on in-the-wild data: The improvement on ChatBot Arena is more modest than on HUMAINE and the synthetic datasets; the authors attribute this to noisy or low-information preference signals under open crowdsourcing, versus HUMAINE's compensated participants and real-time quality monitoring.
• Each design component matters: Ablations show removing the user preference feature drops MT-Bench accuracy to 0.569/AUC 0.507 and MMLU to 0.494/0.613; swapping the cross-attention prediction head for a dot product drops GSM8K accuracy from 0.773 to 0.629; removing user embeddings drops MT-Bench accuracy to 0.569 and MMLU to 0.701.
• The model is small: 27.4M trainable parameters, 109.6MB model size, 4.3GB GPU memory during training — trainable on a single modern GPU.
• Graph construction is cheap relative to encoding: Encoding times range from 4.27s (MMLU) to 142.84s (GSM8K), while graph construction takes 1.49s–2.40s across the four datasets reported in that table.

Methodology in Plain English

The authors start from an "Interaction History Table," where each row records a user ID, the LLM they used, a sequence of turns (query, response, feedback), and the feedback itself — which can be numeric ratings, rankings among candidate responses, or ground-truth answers.

Step 1 — Give every entity a starting vector. Users, LLMs, queries, and responses each become a node type. Query and response texts are embedded with a pretrained language model (Contriever), and LLM nodes are embedded from their API-platform descriptions (model size, cost, domain strengths) rather than just their names. Feedback is converted into a numeric rating: rankings are discretized so higher-ranked responses score higher, and ground-truth feedback is scored by geometric distance between the ground-truth and generated response embeddings. User nodes start as zero vectors, because the authors assume no reliable text profile exists.

Step 2 — Connect them. A fifth, virtual "turn" node is added for each single interaction round, linking the user, LLM, query, and response involved. Turn nodes for consecutive rounds are chained in dialogue order, so information flows across turns and aggregates at the user node.

Step 3 — Train inductively with sampled subgraphs. Instead of training on everything, each epoch samples k interaction histories per user to form a small visible subgraph, with held-out data used as prediction targets. Message passing runs only on that subgraph, which forces the model to learn how to infer preferences from limited evidence. A prediction head uses cross-attention so the LLM embedding attends to the fused user–query context, producing a scalar score per candidate LLM; candidates are ranked by that score. At inference, the same sampling procedure updates embeddings for a new query, and the top-scoring LLM is selected.

Setup details: HGT backbone with 2 layers (single-turn) or 3 (multi-turn), 768-dim hidden, 4-head HGTConv, dropout 0.1; a 4-head cross-attention predictor with a 256-dim MLP; 1000 epochs, learning rate 5e-4, batch size 256 supervision triplets, trained on a single NVIDIA RTX A6000; visible data per user k=10 at both training and inference, with k values of {3, 5, 8, 10, 15, 20} explored.

Data: Two real-world sets (HUMAINE with 20 "users" and 45 LLMs; ChatBot Arena with 11 users and 16 LLMs) and three synthetic sets built from data collected by Ong et al. 2025 using GPT-4-1106-preview and Mixtral-8x7B-Instruct-v0.1 (MT-Bench, GSM8K, MMLU). Synthetic user ratings combine four weighted dimensions — quality, cost, response length, and rare words — with different weights per simulated user. All data is split 7:1:2 into train/validation/test.

Why This Matters

Research impact. The paper reframes LLM routing from a query-only decision into a user-conditioned, multi-turn, graph-structured problem, and the motivation analysis (Spearman self-consistency 0.793 versus global 0.524) provides concrete evidence that preference heterogeneity is large enough to matter. It also shows that heterogeneous graph learning plus inductive sampling can handle the sparse, messy preference data that defeats profile-building and retrieval-based personalization.

Real-world applications.

• Multi-model chat platforms and API gateways that need to route each user's query to a model matching their quality, cost, and style preferences.
• Cost-sensitive enterprise deployments where different users care differently about latency, price, and verbosity, and where per-user tuning data is scarce.
• Cold-start onboarding, where a new user's first few (k=10) interactions are enough to personalize routing without retraining.
• Assistive or educational assistants where individual preferences over answer length and language complexity vary sharply between users.

Industry relevance. Routing is already used in production systems (the paper cites GPT-5 as an example), and the efficiency profile here is notable for deployment: 27.4M trainable parameters, a 109.6MB model, 4.3GB training memory, and single-GPU training with sub-three-second graph construction costs. Because GMTRouter is described as a general framework that can adopt any heterogeneous GNN backbone, it fits into existing routing stacks rather than requiring a bespoke architecture.

Future Directions

1. Fresher LLM representations. LLM node embeddings currently come from static API-platform descriptions, which the authors note may need manual updates when a model is versioned or its performance shifts.
2. Niche high-stakes domains. The authors state that performance in highly specialized areas such as advanced medical or legal sub-specialties remains to be explored.
3. Group-level personalization. The current implementation targets individual users; extending it to collective or group preferences in collaborative environments is flagged as a promising direction.
4. Privacy and bias safeguards. Because interaction histories can be sensitive and personalized routing may inherit or amplify bias in preference data, the authors call for consent, data minimization, access control, and privacy protections in real deployments.

Target Audience

Researchers and engineers working on LLM serving, model routing, and recommendation systems who already understand graph neural networks and want to see personalization and multi-turn structure brought into routing. It is also useful for practitioners building multi-model gateways who need a low-cost, few-shot personalization mechanism, and for students of heterogeneous graph learning looking for a concrete applied case study. Beginners will find the task framing and motivation analysis accessible, but the method sections assume comfort with heterogeneous GNNs and cross-attention.

Authors’ abstract

Large Language Model (LLM) routing has demonstrated strong capability in balancing response quality with computational cost. As users exhibit diverse preferences, personalization has attracted increasing attention in LLM routing, since even identical queries may require different models to generate responses tailored to individual needs. However, existing approaches are not fully personalized and often fail to faithfully capture the complex interactions between users and LLMs. Moreover, user preference data is typically scarce and inconsistent in format, which limits the effectiveness of methods that directly leverage user-specific data. To address these challenges, we propose GMTRouter, which represents multi-turn user-LLM interactions as a heterogeneous graph with five node types: user, LLM, query, response and turn, thereby maximally preserving the rich relational structure of the interaction. Through a lightweight inductive graph learning framework combined with a tailored user-conditioned graph sampling mechanism, GMTRouter learns to capture user preferences from few-shot data, enabling effective personalization. Extensive experiments demonstrate that GMTRouter outperforms the strongest baselines, achieving up to a 0.108 absolute improvement in accuracy and a 0.124 improvement in AUC. More importantly, we further demonstrate that GMTRouter can adapt to new users using only few-shot data, without extensive fine-tuning. The code for GMTRouter is publicly available at https://github.com/ulab-uiuc/GMTRouter.