Query-aware Hub Prototype (QHP)

• QHP is a framework that creates query-adaptive prototypes by leveraging semantic correlations between support and query data, mitigating prototype bias.
• The methodology employs techniques such as bipartite kNN hub mining, transformer-based cross-attention, and dataset-aware query adaptation for dynamic prototype formation.
• Empirical results show QHP improves performance in few-shot segmentation, multi-dataset detection, and LLM orchestration, achieving state-of-the-art metrics across applications.

A Query-aware Hub Prototype (QHP) is a methodological framework and architectural mechanism designed to generate and utilize prototypes that explicitly model semantic correlations between support and query instances in the context of tasks such as few-shot learning, semantic segmentation, and multi-agent orchestration. Unlike conventional metric-based prototype learning, which typically constructs prototypes solely from support data, QHP strategies seek to identify and leverage query-relevant or context-adaptive prototype representations. This approach addresses prototype bias and generalization limitations under distribution shift, and has been generalized to domains ranging from 3D point cloud segmentation to multi-dataset object detection and LLM orchestration.

1. Motivation and Conceptual Foundation

Traditional prototype-based methods aggregate support features to form prototypes for novel-class recognition or segmentation, typically via mean pooling: $$\mathbf{p}_{c} = \frac{1}{|S_c|} \sum_{s_i \in S_c} f(s_i)$$ where $S_c$ is the set of support samples for class $c$, and $f(\cdot)$ is a feature extractor. However, this approach assumes that support and query data are sampled from similar distributions, resulting in prototype bias when semantic or distributional discrepancies are present (e.g., geometry variations in 3D segmentation, category taxonomy changes in object detection). The QHP paradigm introduces mechanisms to make prototype construction or query handling explicitly aware of query data, greatly improving the alignment between support-driven representations and task-specific queries (Zhou et al., 9 Dec 2025, Meng et al., 2022, Cao et al., 2022).

2. Core Algorithmic Components

QHP methods are instantiated via domain-specific modules, but share key elements:

• Query-Conditioned Prototype Generation: Rather than forming prototypes solely from support data, QHP algorithms mine or adjust prototypes by establishing explicit relationships (e.g., correlations, graph edges, cross-attention) between support and query instances.
• Hub Prototype Selection (3D Segmentation): In 3D few-shot segmentation, QHP employs a bipartite $k$NN graph between support and query points. Support points most frequently linked by query points (high hubness score) are selected as "support hubs," and prototypes are locally clustered around them. This ensures that prototypes represent the actual semantic support-query intersection (Zhou et al., 9 Dec 2025).
• Query-Aware Query Adaptation (Detection Hub): In multi-dataset object detection, QHP adapts object queries via learned dataset embeddings and cross-attention blocks, producing dataset-aware query vectors that condition the detection head and enable dynamic convolutional kernel adaptation (Meng et al., 2022).
• Prototype-to-Query Attention (Semantic Segmentation): In few-shot segmentation, QHP (as in ProtoFormer) treats support prototypes as Transformer "queries" and query features as keys/values, enabling spatially-dense cross-attention and the generation of semantic-aware dynamic kernels for mask prediction (Cao et al., 2022).
• Fusion of Support and Query Prototypes: In medical image segmentation, QHP variants fuse support prototypes with query-derived prototypes (obtained via coarse mask prediction and masked average pooling on the query feature map) to form a final, query-refined prototype for segmentation (Wu et al., 13 May 2024).

3. Mathematical Formulation and Workflow Examples

The table below summarizes representative QHP mechanisms from major application domains:

Domain	QHP Mechanism	Query-aware Step
3D Segmentation	Bipartite $k$NN hub mining + purity weighting	Prototypes formed at support points frequent in query $k$NN graphs (Zhou et al., 9 Dec 2025)
Detection	Dataset embedding + query adaptation via XAttn	Queries adapted by dataset, dynamic heads modulated accordingly (Meng et al., 2022)
2D Segmentation	Proto-as-Query Transformer (decoder)	Prototype as Transformer query over query feature field (Cao et al., 2022)
Medical Imaging	Support-query prototype fusion (weighted sum)	Final prototype as $\alpha p_s + \beta p_q$; $p_q$ pooled over confident query mask (Wu et al., 13 May 2024)

A typical QHP algorithm for 3D few-shot segmentation follows these principal steps (Zhou et al., 9 Dec 2025):

1. Extract point-wise features for support and query sets.
2. Construct a bipartite $k$NN graph from each query point to the closest support points.
3. Identify "hub" support points with high connectivity to the query set.
4. Generate prototypes by locally clustering around these hubs.
5. Refine prototype distribution via purity-weighted contrastive loss, penalizing ambiguous or "bad" hubs.

4. Loss Functions and Prototype Optimization

In QHP methods, the loss function incorporates both standard task supervision (e.g., cross-entropy, Dice loss on query predictions) and specialized terms for prototype optimization.

• Purity-Weighted Contrastive Loss: For ambiguous or impure hub prototypes (i.e., those matched to query points of divergent labels), a purity function $\mathcal{P}(h)$ and a weight $w(a)$ penalize low-purity anchors: $$\mathcal{L}_{\mathrm{PC}} = -\frac{1}{|\mathcal{A}|} \sum_{a\in\mathcal{A}} \log \frac{w(a)U^+(a)}{w(a)U^+(a) + U^-(a)}$$ with positive and negative prototype pools $P^+(a)$ and $P^-(a)$ computed over label agreement.
• Total Loss: The combined loss is typically

$$\mathcal{L}_{\mathrm{total}} = \mathcal{L}_{\mathrm{CE}} + \lambda \mathcal{L}_{\mathrm{PC}}$$

where $\lambda$ controls the influence of prototype distribution optimization (Zhou et al., 9 Dec 2025).

• Attention and Embedding Alignment Loss: In Detection Hub-style QHP, alignment losses regularize dataset and class embeddings to encourage semantic coherence across datasets (Meng et al., 2022).

5. Comparison Across Domains and Experimental Results

QHP mechanisms have been adapted for:

• Few-Shot 3D Point Cloud Segmentation: On S3DIS and ScanNet, QHP outperforms prior methods (e.g., COSeg) by 1–3 mIoU points in both 1-shot and 5-shot settings. Ablation shows the necessity of both hub prototype generation (HPG) and prototype distribution optimization (PDO), with best results at $\lambda=0.1$ for $\mathcal{L}_{\mathrm{PC}}$ (Zhou et al., 9 Dec 2025).
• Multi-Dataset Object Detection: Query adaptation via dataset-aware embeddings and language-aligned projection yields substantial improvements: on UODB, QHP achieves 71.0 AP$_{50}$ vs. 59.4 for separate training. Query adaptation and category alignment are critical components, as shown in ablations (Meng et al., 2022).
• Few-Shot 2D Segmentation (ProtoFormer): Using prototype as Transformer query for mask generation, QHP improves mean mIoU on PASCAL-5$^i$ from 60.8% (PFENet) to 63.1% (ProtoFormer), and on COCO-20$^i$ from 39.2% (HSNet) to 45.7%, setting new SOTA (Cao et al., 2022).
• Few-Shot Medical Image Segmentation: Support-query prototype fusion (SQPFNet) achieves 77.00% mean Dice on SABS (1-way-1-shot, seen) and 69.87% on unseen classes, outperforming prior SOTA (Wu et al., 13 May 2024).

6. Extensions to Multi-Agent Systems and Workflow Orchestration

The QHP paradigm has been structurally extended to orchestrate multi-agent LLM systems for telecom networks, as in the Tele-LLM-Hub. In this context, the "hub prototype" maps to a core architectural router mediating context-typed messages (via TeleMCP protocol) between specialized agent instances. The low-code MA-Maker and RANSTRUCT fine-tuning streamlines agent instantiation and domain grounding. The overall framework supports context- and query-driven agent composition and contextual workflow deployment (Shah et al., 12 Nov 2025).

Key QHP features in this domain:

• TeleMCP as a formalized protocol for context-rich query exchanges.
• DAG-structured workflow execution with explicit query/context routing.
• Agent Maker and MA-Maker to instantiate and compose query-adaptive multi-agent systems.

7. Discussion: Limitations and Generalization

QHP methods represent a significant advance over support-only prototype learning under distribution or domain shift, as shown empirically in segmentation and detection tasks. Outstanding challenges include protocol standardization for cross-agent or multi-dataset QHPs, scalable hub selection under large-scale input, and robustness to adversarial or irrelevant queries. A plausible implication is that further integrating domain or context-awareness in prototype optimization will yield continued gains in generalization to unseen or distribution-shifted data.

QHP architectural patterns and mathematical strategies are reusable across vision, language, and multi-agent system domains provided that the context/prototype interface and the query-hub adaptation mechanism are informed by the target task semantics (Zhou et al., 9 Dec 2025, Meng et al., 2022, Cao et al., 2022, Shah et al., 12 Nov 2025, Wu et al., 13 May 2024).