The Router Within 2026: Eliciting Native Skill Routing dari Frozen LLMs Tanpa In-Context Metadata Pollution

1. Krisis In-Context Tool Overload & RAG Latency Tax

Dalam implementasi AI Agent enterprise standar (seperti Model Context Protocol/MCP atau OpenAI Functions), paradigma dominan untuk memberi tahu agen mengenai kapabilitas perkakas adalah melalui in-context definition injection: seluruh skema JSON, deskripsi parameter, dan petunjuk penggunaan disuntikkan ke dalam system prompt.

Pendekatan ini memicu tiga kegagalan struktural fatal ketika perpustakaan perkakas berkembang melebihi 20 alat:

• Attention Dispersion (Kepadatan Perhatian Terpecah): Semakin panjang deskripsi perkakas di prompt awal, semakin lemah bobot atensi model pada instruksi inti pengguna (fenomena needle-in-a-haystack decay).
• Token Cost Explosion: Menyuntikkan 80 skema tools menghabiskan 8.000 hingga 15.000 token pada setiap turn percakapan, melipatgandakan biaya inferensi dan menaikkan Time-to-First-Token (TTFT) secara drastis.
• RAG Decoupling Failure: Solusi alternatif menggunakan dense retrieval (embedding search eksternal seperti bge-large atau text-embedding-3) kerap gagal menangkap maksud implisit pengguna karena terputus dari konteks percakapan multi-turn yang sedang dipegang oleh LLM.

2. Mekanisme Representasi Intrinsik pada Hidden State Frozen LLM

Penelitian Chen et al. menemukan bahwa model LLM modern (seperti Llama-3-70B, Qwen-2.5, dan GLM-4) tidak memerlukan deskripsi tekstual tools untuk mengetahui apa yang harus dilakukan berikutnya. Selama proses membaca prompt pengguna, lapisan transformer bagian atas (layers 24-32) telah membentuk intent trajectory yang sangat terpolarisasi.

Ketika pengguna mengetik "Cari tahu kenapa test suite auth gagal di commit terakhir", hidden state dari token terakhir mengandung representasi semantik tingkat tinggi yang secara geometri lebih dekat dengan konsep git_diff dan terminal_execution dibanding konsep pencarian web umum, bahkan tanpa model pernah melihat nama fungsi tersebut dalam prompt.

3. Perumusan Matematis: Two Linear Maps & Latent Skill Projection

Daripada melatih ulang transformer (fine-tuning) yang berisiko merusak reasoning general, The Router Within memformulasikan routing sebagai mekanisme ekstraksi linear ringan:

Di mana:

• h_last ∈ ℝ^D adalah vektor representasi tersembunyi dari token terakhir urutan input.
• W_1 ∈ ℝ^{d × D} dan W_2 ∈ ℝ^{d × d} adalah parameter pemetaan linear yang dilatih dengan contrastive routing objective.
• e_i ∈ ℝ^d adalah embedding kanonikal dari skill/tool ke-i dalam ruang laten berdimensi rendah (d=512).
• τ adalah parameter temperatur terkalibrasi (default: 0.07).

4. Data Empiris & Benchmark Akurasi vs Retrieval Pipelines

5. Implementasi Referensi Produksi: NativeSkillRouter Engine

Berikut implementasi arsitektur PyTorch murni untuk mengintegrasikan router ini pada layer inferensi serverless atau AI runtime gateway:

"""
The Router Within: Native Hidden-State Skill Routing Architecture
Berdasarkan Inovasi arXiv:2609.15982 (Chen et al., September 2026).
Dua linear projection map untuk mengekstrak sinyal pemilihan skill langsung dari representasi forward-pass frozen LLM.
"""

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List, Dict, Tuple, Optional

class NativeSkillRouter(nn.Module):
    """
    Ekstraktor sinyal routing skill berbasis representasi internal model.
    Menghindari injeksi ratusan deskripsi tools ke context window dengan memetakan
    hidden state layer perantara model ke embedding ruang kemampuan (skill space).
    """
    def __init__(
        self,
        hidden_dim: int = 4096,
        skill_latent_dim: int = 512,
        num_skills: int = 128,
        temperature: float = 0.07,
    ):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.skill_latent_dim = skill_latent_dim
        self.num_skills = num_skills
        self.temperature = temperature

        # Map 1: Proyeksi forward pass hidden state token terakhir ke ruang routing
        self.state_projector = nn.Sequential(
            nn.Linear(hidden_dim, skill_latent_dim, bias=False),
            nn.LayerNorm(skill_latent_dim),
            nn.GELU(),
            nn.Linear(skill_latent_dim, skill_latent_dim, bias=False),
        )

        # Map 2: Representasi kanonikal skill matriks (Bank Embeddings)
        self.skill_embeddings = nn.Parameter(
            torch.randn(num_skills, skill_latent_dim) * 0.02
        )

        # Gating threshold untuk menentukan apakah tool invocation diperlukan
        self.activation_gate = nn.Linear(skill_latent_dim, 1)

    def forward(
        self,
        frozen_hidden_states: torch.Tensor,
        candidate_mask: Optional[torch.Tensor] = None
    ) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        Input:
            frozen_hidden_states: [batch_size, hidden_dim] - hidden state token penutup dari frozen LLM
            candidate_mask: [batch_size, num_skills] - optional mask untuk permission scoping
        Output:
            routing_probs: [batch_size, num_skills] - distribusi probabilitas pemilihan skill
            need_tool: [batch_size, 1] - probabilitas sigmoid bahwa intervensi alat dibutuhkan
        """
        # Proyeksikan representasi internal ke skill latent space
        query_latent = self.state_projector(frozen_hidden_states)
        query_norm = F.normalize(query_latent, p=2, dim=-1)
        skill_norm = F.normalize(self.skill_embeddings, p=2, dim=-1)

        # Hitung dot-product similarity terkalibrasi temperatur
        logits = torch.matmul(query_norm, skill_norm.t()) / self.temperature

        if candidate_mask is not None:
            logits = logits.masked_fill(~candidate_mask, -1e9)

        routing_probs = F.softmax(logits, dim=-1)
        need_tool = torch.sigmoid(self.activation_gate(query_latent))

        return routing_probs, need_tool

class FrozenLLMSkillDispatcher:
    """Harness runtime untuk mengeksekusi routing deterministik pada agent production."""
    def __init__(self, router: NativeSkillRouter, skill_registry: List[Dict[str, str]]):
        self.router = router
        self.skill_registry = skill_registry

    def select_skill(self, last_hidden_state: torch.Tensor, top_k: int = 3) -> List[Dict]:
        with torch.no_grad():
            probs, need_tool = self.router(last_hidden_state)
            if need_tool.item() < 0.5:
                return []  # Model memutuskan tidak membutuhkan tool eksternal

            top_scores, top_indices = torch.topk(probs, k=top_k, dim=-1)
            selected = []
            for score, idx in zip(top_scores[0].tolist(), top_indices[0].tolist()):
                skill_meta = self.skill_registry[idx].copy()
                skill_meta["confidence"] = round(score, 4)
                selected.append(skill_meta)
            return selected

6. Panduan Arsitektur & Mitigasi di Lini Rekayasa Agentic 2026