Registration and Discovery Extension for Multi-Model Agents

Introduction Intelligent agents built upon large language models (LLMs) have been widely deployed as core service components within AI-native systems. Conventional agent registration and discovery mechanisms expose static metadata, such as agent identifiers, service endpoints, authentication schemes, and supported capability catalogs. These mechanisms operate under an implicit assumption that each agent is backed by only one inference model, and key service metrics including latency and functional capability remain stable and deterministic. This foundational assumption, however, no longer holds true in production deployments. Most modern agents incorporate internal model routing capabilities, which dynamically select distinct foundation models at runtime to achieve balanced tradeoffs among inference latency, invocation cost, and output quality. The broad adoption of intra-agent multi-model routing stems from two primary production scenarios. Tiered Model Scheduling for Latency-Cost Balance: A single business-oriented agent integrates lightweight small-scale models, medium general-purpose models, and high-performance flagship models. Trivial routine queries are handled by low-latency, low-cost small models, while tasks involving sophisticated logical reasoning, long-document parsing, and mathematical computation are automatically routed to high-capacity flagship models. Downstream systems only need to connect to a unified service entry without manual model selection or switching. Load-Adaptive Degradation and Fault Fallback: During traffic surges or GPU resource saturation, the routing module automatically offloads heavy-load requests from flagship models onto lightweight backup models to prevent request timeouts and sustain uninterrupted service. The full degradation and disaster recovery logic is fully transparent to external service discovery modules. From an external perspective, such agents appear as a single logical service entity, yet their internal runtime execution behaviors exhibit substantial heterogeneity.

Problem Statement

Emergence of Internal Model Routing in Production Systems In modern deployments of LLM-based agents, it is increasingly common for a single agent system to incorporate multiple foundation models internally. These systems typically implement internal routing mechanisms that dynamically select models based on runtime conditions such as request complexity, system load, latency constraints, and cost optimization policies. Although multiple models may be involved in execution, this routing logic is generally not exposed to external registration or discovery systems. As a result, the agent continues to be represented as a single static service entity.

Hidden Execution Heterogeneity While an agent is registered as a single endpoint, its runtime behavior may vary significantly depending on which internal model is selected for a given request. Service-level characteristics such as latency, response quality, and cost are therefore not fixed attributes of the agent, but emergent properties of internal execution decisions. This leads to a situation where identical requests may receive different service-level outcomes depending on internal routing decisions that are not visible externally.

Lack of Transparency in Model Selection Behavior Current registration and discovery mechanisms do not provide visibility into:

how internal models are selected for different request types
when fallback or degradation occurs
how latency, cost, and quality trade-offs are enforced internally

This lack of transparency prevents external systems from accurately reasoning about expected service behavior.

Impact on Discovery and QoS Matching The absence of model-level or execution-level visibility leads to inaccurate discovery decisions. In particular:

agents may be selected without awareness of internal fallback behavior
latency expectations may be violated due to hidden model switching
cost-efficient routing decisions cannot be enforced externally
high-complexity requests may be routed to insufficient capability paths under degradation

These issues arise because current systems rely on static metadata that does not reflect dynamic execution behavior.

Limitations of Static Agent-Level Representation Existing registration models assume that an agent can be described using a single, stable capability profile. However, in multi-model routing systems:

capability is not static but context-dependent
execution paths are dynamic and non-deterministic
service-level characteristics vary across requests

Therefore, static registration information is insufficient to accurately represent real-world agent behavior.

Requirement for Execution-Aware Representation There is a requirement for registration and discovery systems to evolve beyond static capability descriptions and support representations that reflect:

dynamic execution behavior within agents
variability in service-level outcomes
internal heterogeneity of model usage

Such support is necessary to enable accurate service discovery and QoS-aware routing in environments where multiple models are used within a single agent system.

Design Goals The following design goals are defined for the extension mechanism:

G1: Support representation of heterogeneous execution behavior within a single agent
G2: Capture dynamic variability of service characteristics
G3: Enable QoS-aware discovery and matching
G4: Preserve single-endpoint abstraction
G5: Maintain backward compatibility with existing systems

Protocol Overview The system consists of the following entities:

Agent: service provider with internal execution pipeline
Registration Center: maintains metadata
Service Consumer: performs discovery and invocation

Figure 1 illustrates the overall architecture of the extended registration and discovery framework.

Registration Extension This section defines the extended registration format for agents with internal multi-model routing capabilities.

Agent Registration Format The extended registration format includes the following fields:

Agent-ID: unique identifier for the agent
Agent-Type: classification of the agent
Endpoint: service endpoint URI
Authentication: authentication information
Skill-List: list of supported skills
Model-Profile-List: list of internal model profiles (NEW)

Model Profile Each Model Profile contains the following fields:

Model-ID: unique identifier for the model within the agent
Model-Type: model architecture or family
Model-Version: version identifier
Capability-Level: capability classification
Latency-Class: expected latency classification
Context-Length: maximum supported context length
Cost-Class: cost classification
Availability: availability status
Supported-Skills: skills supported by this model

Model Update Procedure Agents SHOULD report internal model lifecycle changes to the Registration Center. The following update types are defined:

MODEL_ADDED: a new model has been added to the agent
MODEL_REMOVED: an existing model has been removed from the agent
MODEL_UPDATED: properties of an existing model have changed
MODEL_DEGRADED: a model has entered a degraded state

Upon receiving an update notification, the Registration Center SHOULD update the corresponding Model Profile entries and notify affected consumers if necessary.

Discovery Extension This section defines the extended discovery mechanism that enables consumers to perform QoS-aware service selection.

Discovery Request The extended discovery request includes the following fields:

Required-Skill: the skill required for the request
Maximum-Latency: maximum acceptable latency
Minimum-Capability: minimum required capability level
Minimum-Context-Length: minimum required context length
Cost-Preference: preferred cost classification

Discovery Response The extended discovery response includes the following fields:

Agent-ID: identifier of the matched agent
Matched-Model: identifier of the model that matches the request
Capability-Level: capability level of the matched model
Expected-Latency: expected latency for the matched model
Endpoint: service endpoint for invocation

Backward Compatibility Single-model agents are represented using a single default Model Profile entry. No protocol changes are required for existing implementations. Registration Centers that do not support the extended format MAY ignore the Model-Profile-List field and treat the agent as a traditional single-model agent. Consumers that do not support the extended format MAY continue to use the basic discovery mechanism without the QoS-aware fields.

Security Considerations Model-level information MAY reveal sensitive system characteristics. Implementations SHOULD:

protect registration and update messages using appropriate security mechanisms
restrict exposure of internal model identities to authorized consumers
prefer abstract capability representation where possible to avoid revealing sensitive model details

Registration Centers SHOULD implement access control policies to limit which consumers can access detailed Model Profile information.

IANA Considerations This document does not require any IANA actions.

Conclusion This document describes an emerging gap in current agent registration and discovery systems caused by internal multi-model routing within modern agent architectures. It identifies the need for execution-aware representation of agent behavior to enable accurate discovery and QoS-aware service selection in future AI-native networks. The design goals, protocol overview, and extension mechanisms defined in this document provide a foundation for addressing this gap while maintaining backward compatibility with existing systems.