diff --git a/backend/consts/model.py b/backend/consts/model.py
index 2b4903c33..6bf368d7b 100644
--- a/backend/consts/model.py
+++ b/backend/consts/model.py
@@ -587,6 +587,12 @@ class AgentSkillInstanceRequest(BaseModel):
 
 
 # used in agent/search agent/update for save agent info
+class RelatedAgentInfo(BaseModel):
+    """Related agent info with pinned version."""
+    agent_id: int
+    version_no: Optional[int] = None
+
+
 class AgentInfoRequest(BaseModel):
     agent_id: Optional[int] = None
     name: Optional[str] = None
@@ -611,6 +617,7 @@ class AgentInfoRequest(BaseModel):
     enabled_skill_ids: Optional[List[int]] = None
     skill_instances: Optional[List[AgentSkillInstanceRequest]] = None
     related_agent_ids: Optional[List[int]] = None
+    related_agents: Optional[List[RelatedAgentInfo]] = None  # Related agents with pinned versions
     related_external_agent_ids: Optional[List[int]] = None
     group_ids: Optional[List[int]] = None
     ingroup_permission: Optional[str] = None
diff --git a/backend/database/agent_db.py b/backend/database/agent_db.py
index df7410115..ecdcb6336 100644
--- a/backend/database/agent_db.py
+++ b/backend/database/agent_db.py
@@ -339,7 +339,32 @@ def query_all_agent_info_by_tenant_id(tenant_id: str, version_no: int = 0):
         return [as_dict(agent) for agent in agents]
 
 
-def insert_related_agent(parent_agent_id: int, child_agent_id: int, tenant_id: str, user_id: str, version_no: int = 0) -> bool:
+def batch_search_agent_display_names(agent_ids: List[int], tenant_id: str) -> dict:
+    """
+    Batch query agent display names by agent IDs.
+    Returns a dict mapping agent_id -> display_name (falls back to name).
+
+    Args:
+        agent_ids: List of agent IDs to query
+        tenant_id: Tenant ID
+    """
+    if not agent_ids:
+        return {}
+    with get_db_session() as session:
+        agents = session.query(
+            AgentInfo.agent_id,
+            AgentInfo.display_name,
+            AgentInfo.name
+        ).filter(
+            AgentInfo.agent_id.in_(agent_ids),
+            AgentInfo.tenant_id == tenant_id,
+            AgentInfo.version_no == 0,
+            AgentInfo.delete_flag != 'Y'
+        ).all()
+        return {a.agent_id: (a.display_name or a.name) for a in agents}
+
+
+def insert_related_agent(parent_agent_id: int, child_agent_id: int, tenant_id: str, user_id: str, version_no: int = 0, selected_agent_version_no: Optional[int] = None) -> bool:
     """
     Insert a related agent.
     Default version_no=0 creates the draft version.
@@ -349,7 +374,8 @@ def insert_related_agent(parent_agent_id: int, child_agent_id: int, tenant_id: s
         child_agent_id: Child agent ID
         tenant_id: Tenant ID
         user_id: User ID
-        version_no: Version number. Default 0 = draft/editing state
+        version_no: Parent agent version number. Default 0 = draft/editing state
+        selected_agent_version_no: Pinned version of child agent. None = runtime fallback to child current_version_no
     """
     try:
         relation_info = {
@@ -357,6 +383,7 @@ def insert_related_agent(parent_agent_id: int, child_agent_id: int, tenant_id: s
             "selected_agent_id": child_agent_id,
             "tenant_id": tenant_id,
             "version_no": version_no,
+            "selected_agent_version_no": selected_agent_version_no,
             "created_by": user_id,
             "updated_by": user_id
         }
@@ -398,22 +425,77 @@ def delete_related_agent(parent_agent_id: int, child_agent_id: int, tenant_id: s
         return False
 
 
-def update_related_agents(parent_agent_id: int, related_agent_ids: List[int], tenant_id: str, user_id: str, version_no: int = 0):
+def _parse_related_agents(related_agents: Optional[List[dict]]) -> tuple:
+    """Extract agent_id set and version_map from related_agents list."""
+    new_related_ids: set = set()
+    version_map: dict = {}
+    if not related_agents:
+        return new_related_ids, version_map
+    for rel in related_agents:
+        agent_id = rel.get("agent_id")
+        if agent_id is None:
+            continue
+        new_related_ids.add(agent_id)
+        version_no_val = rel.get("version_no")
+        if version_no_val is not None:
+            version_map[agent_id] = version_no_val
+    return new_related_ids, version_map
+
+
+def _add_new_relations(session, parent_agent_id, tenant_id, user_id, version_no, ids_to_add, version_map):
+    """Insert new agent relations into the database."""
+    for child_agent_id in ids_to_add:
+        relation_info = {
+            "parent_agent_id": parent_agent_id,
+            "selected_agent_id": child_agent_id,
+            "tenant_id": tenant_id,
+            "version_no": version_no,
+            "created_by": user_id,
+            "updated_by": user_id,
+        }
+        if child_agent_id in version_map:
+            relation_info["selected_agent_version_no"] = version_map[child_agent_id]
+        new_relation = AgentRelation(**filter_property(relation_info, AgentRelation))
+        session.add(new_relation)
+
+
+def _update_existing_relations(current_relations, ids_to_update, version_map, user_id):
+    """Update version_no for existing relations."""
+    if not ids_to_update or not version_map:
+        return
+    for rel in current_relations:
+        if rel.selected_agent_id not in ids_to_update:
+            continue
+        new_version_no = version_map.get(rel.selected_agent_id)
+        if new_version_no is not None:
+            rel.selected_agent_version_no = new_version_no
+            rel.updated_by = user_id
+
+
+def update_related_agents(
+    parent_agent_id: int,
+    tenant_id: str,
+    user_id: str,
+    related_agents: Optional[List[dict]] = None,
+    version_no: int = 0,
+):
     """
     Update related agents for a parent agent by replacing all existing relations.
     Default version_no=0 updates the draft version.
 
     This function handles both creation and deletion of relations in a single transaction.
+    related_agents is the single source of truth: each item has 'agent_id' and optional 'version_no'.
 
     Args:
         parent_agent_id: ID of the parent agent
-        related_agent_ids: List of child agent IDs to be related
         tenant_id: Tenant ID
         user_id: User ID for audit trail
+        related_agents: List of dicts with 'agent_id' and optional 'version_no' keys
         version_no: Version number to filter. Default 0 = draft/editing state
     """
+    new_related_ids, version_map = _parse_related_agents(related_agents)
+
     with get_db_session() as session:
-        # Get current relations
         current_relations = session.query(AgentRelation).filter(
             AgentRelation.parent_agent_id == parent_agent_id,
             AgentRelation.tenant_id == tenant_id,
@@ -421,17 +503,12 @@ def update_related_agents(parent_agent_id: int, related_agent_ids: List[int], te
             AgentRelation.delete_flag != 'Y'
         ).all()
 
-        current_related_ids = {
-            rel.selected_agent_id for rel in current_relations}
-        new_related_ids = set(
-            related_agent_ids) if related_agent_ids else set()
+        current_related_ids = {rel.selected_agent_id for rel in current_relations}
 
-        # Find IDs to delete (in current but not in new)
         ids_to_delete = current_related_ids - new_related_ids
-        # Find IDs to add (in new but not in current)
         ids_to_add = new_related_ids - current_related_ids
+        ids_to_update = current_related_ids & new_related_ids
 
-        # Soft delete removed relations
         if ids_to_delete:
             session.query(AgentRelation).filter(
                 AgentRelation.parent_agent_id == parent_agent_id,
@@ -443,19 +520,11 @@ def update_related_agents(parent_agent_id: int, related_agent_ids: List[int], te
                 synchronize_session=False
             )
 
-        # Add new relations
-        for child_agent_id in ids_to_add:
-            relation_info = {
-                "parent_agent_id": parent_agent_id,
-                "selected_agent_id": child_agent_id,
-                "tenant_id": tenant_id,
-                "version_no": version_no,
-                "created_by": user_id,
-                "updated_by": user_id
-            }
-            new_relation = AgentRelation(
-                **filter_property(relation_info, AgentRelation))
-            session.add(new_relation)
+        _add_new_relations(
+            session, parent_agent_id, tenant_id, user_id, version_no, ids_to_add, version_map
+        )
+
+        _update_existing_relations(current_relations, ids_to_update, version_map, user_id)
 
 
 def delete_agent_relationship(agent_id: int, tenant_id: str, user_id: str, version_no: int = 0):
diff --git a/backend/database/agent_version_db.py b/backend/database/agent_version_db.py
index c0785c527..391e5d5e8 100644
--- a/backend/database/agent_version_db.py
+++ b/backend/database/agent_version_db.py
@@ -35,6 +35,36 @@ def search_version_by_version_no(
         return as_dict(version) if version else None
 
 
+def batch_search_version_names(
+    agent_ids: List[int],
+    tenant_id: str,
+    version_nos: List[int],
+) -> List[dict]:
+    """
+    Batch query version names for multiple (agent_id, version_no) pairs.
+
+    Returns list of dicts: [{"agent_id": int, "version_no": int, "version_name": Optional[str]}]
+    """
+    if not agent_ids or not version_nos:
+        return []
+
+    with get_db_session() as session:
+        versions = session.query(AgentVersion).filter(
+            AgentVersion.agent_id.in_(agent_ids),
+            AgentVersion.version_no.in_(version_nos),
+            AgentVersion.tenant_id == tenant_id,
+        ).all()
+
+        result = []
+        for v in versions:
+            result.append({
+                "agent_id": v.agent_id,
+                "version_no": v.version_no,
+                "version_name": v.version_name,
+            })
+        return result
+
+
 def search_version_by_id(
     version_id: int,
     tenant_id: str,
@@ -87,6 +117,42 @@ def query_current_version_no(
         return agent.current_version_no if agent else None
 
 
+def batch_query_current_version_nos(
+    agent_ids: List[int],
+    tenant_id: str,
+) -> dict:
+    """
+    Batch query current published version_no for multiple agents.
+
+    Returns a dict mapping agent_id -> current_version_no (only includes agents
+    that have a non-null current_version_no).
+
+    Args:
+        agent_ids: List of agent IDs to query
+        tenant_id: Tenant ID
+    """
+    if not agent_ids:
+        return {}
+    with get_db_session() as session:
+        agents = session.query(
+            AgentInfo.agent_id,
+            AgentInfo.current_version_no,
+        ).filter(
+            AgentInfo.agent_id.in_(agent_ids),
+            or_(
+                AgentInfo.tenant_id == tenant_id,
+                AgentInfo.tenant_id == ASSET_OWNER_TENANT_ID,
+            ),
+            AgentInfo.version_no == 0,
+            AgentInfo.delete_flag == 'N',
+        ).all()
+        return {
+            a.agent_id: a.current_version_no
+            for a in agents
+            if a.current_version_no is not None
+        }
+
+
 def query_agent_snapshot(
     agent_id: int,
     tenant_id: str,
diff --git a/backend/database/db_models.py b/backend/database/db_models.py
index 190b19694..3a6a27fa9 100644
--- a/backend/database/db_models.py
+++ b/backend/database/db_models.py
@@ -1074,18 +1074,19 @@ class UserTenant(TableBase):
 class AgentRelation(TableBase):
     """
     Agent parent-child relationship table
+    Primary key: (relation_id, version_no)
     """
     __tablename__ = "ag_agent_relation_t"
     __table_args__ = {"schema": SCHEMA}
 
     relation_id = Column(Integer, Sequence("ag_agent_relation_t_relation_id_seq", schema=SCHEMA),
                          primary_key=True, nullable=False, doc="Relationship ID, primary key")
+    version_no = Column(Integer, primary_key=True, default=0, nullable=False,
+                        doc="Version number. 0 = draft/editing state, >=1 = published snapshot")
     selected_agent_id = Column(
-        Integer, primary_key=True, doc="Selected agent ID")
+        Integer, doc="Selected agent ID")
     parent_agent_id = Column(Integer, doc="Parent agent ID")
     tenant_id = Column(String(100), doc="Tenant ID")
-    version_no = Column(Integer, default=0, nullable=False,
-                        doc="Version number. 0 = draft/editing state, >=1 = published snapshot")
     selected_agent_version_no = Column(
         Integer, nullable=True,
         doc="Pinned version of selected_agent_id. NULL = runtime fallback to child current_version_no",
diff --git a/backend/services/agent_service.py b/backend/services/agent_service.py
index abf6026f1..240ea4367 100644
--- a/backend/services/agent_service.py
+++ b/backend/services/agent_service.py
@@ -42,6 +42,7 @@
 )
 from services.asset_owner_visibility import resolve_agent_list_permission
 from database.agent_db import (
+    batch_search_agent_display_names,
     create_agent,
     delete_agent_by_id,
     delete_agent_relationship,
@@ -80,7 +81,7 @@
 from database.attachment_db import upload_fileobj
 from services.skill_service import SkillService
 from services.file_management_service import is_allowed_skill_upload_path
-from database.agent_version_db import query_version_list, query_current_version_no
+from database.agent_version_db import query_version_list, query_current_version_no, batch_search_version_names, batch_query_current_version_nos
 from database.group_db import query_group_ids_by_user
 from database.user_tenant_db import get_user_tenant_by_user_id
 from database.a2a_agent_db import get_server_agent_ids, query_external_sub_agents
@@ -1487,9 +1488,80 @@ async def get_agent_info_impl(agent_id: int, tenant_id: str, version_no: int = 0
         sub_agent_id_list = query_sub_agents_id_list(
             main_agent_id=agent_id, tenant_id=tenant_id)
         agent_info["sub_agent_id_list"] = sub_agent_id_list
+
+        # Enrich sub-agent relations with version names (batch query)
+        relations = query_sub_agent_relations(agent_id, tenant_id, version_no)
+        enriched_relations = []
+
+        # Collect all agent_ids and (agent_id, version_no) pairs for batch lookup
+        all_agent_ids = set()
+        lookup_agent_ids = set()
+        lookup_version_nos = set()
+        # Track agents whose pinned version_no is null -> need to resolve latest published version
+        missing_version_agent_ids = set()
+        for rel in relations:
+            aid = rel.get("selected_agent_id")
+            if aid:
+                all_agent_ids.add(aid)
+            vno = rel.get("selected_agent_version_no")
+            if aid and vno is not None and vno != 0:
+                lookup_agent_ids.add(aid)
+                lookup_version_nos.add(vno)
+            elif aid:
+                # Historical data: pinned version_no is null or 0 (draft), resolve from child's current published version
+                missing_version_agent_ids.add(aid)
+
+        # Batch query current published version_no for agents with missing pinned version
+        resolved_version_no_map: dict = {}
+        if missing_version_agent_ids:
+            resolved_version_no_map = batch_query_current_version_nos(
+                agent_ids=list(missing_version_agent_ids),
+                tenant_id=tenant_id,
+            )
+            # Merge resolved version_nos into the version name lookup set
+            for aid, resolved_vno in resolved_version_no_map.items():
+                lookup_agent_ids.add(aid)
+                lookup_version_nos.add(resolved_vno)
+
+        # Batch query all version names at once
+        version_name_map: dict = {}
+        if lookup_agent_ids and lookup_version_nos:
+            batch_results = batch_search_version_names(
+                agent_ids=list(lookup_agent_ids),
+                tenant_id=tenant_id,
+                version_nos=list(lookup_version_nos),
+            )
+            for item in batch_results:
+                key = (item["agent_id"], item["version_no"])
+                version_name_map[key] = item["version_name"]
+
+        # Batch query all agent display names at once
+        agent_name_map = batch_search_agent_display_names(
+            agent_ids=list(all_agent_ids),
+            tenant_id=tenant_id,
+        )
+
+        for rel in relations:
+            selected_agent_id = rel.get("selected_agent_id")
+            selected_version_no = rel.get("selected_agent_version_no")
+            # Fallback to resolved latest published version_no when pinned version is null or 0 (draft)
+            if (selected_version_no is None or selected_version_no == 0) and selected_agent_id in resolved_version_no_map:
+                selected_version_no = resolved_version_no_map[selected_agent_id]
+            version_name = None
+            if selected_agent_id and selected_version_no is not None:
+                version_name = version_name_map.get((selected_agent_id, selected_version_no))
+            enriched_relations.append({
+                "agent_id": selected_agent_id,
+                "agent_name": agent_name_map.get(selected_agent_id) if selected_agent_id else None,
+                "version_no": selected_version_no,
+                "version_name": version_name,
+            })
+
+        agent_info["sub_agent_relations"] = enriched_relations
     except Exception as e:
         logger.error(f"Failed to get sub agent id list: {str(e)}")
         agent_info["sub_agent_id_list"] = []
+        agent_info["sub_agent_relations"] = []
 
     try:
         skill_service = SkillService()
@@ -1886,12 +1958,23 @@ async def update_agent_info_impl(request: AgentInfoRequest, authorization: str =
                     main_agent_id=left_ele, tenant_id=tenant_id)
                 search_list.extend(sub_ids)
 
-            # Update related agents
+            # Update related agents - use related_agents if provided, otherwise build from IDs
+            if request.related_agents:
+                related_agents_dicts = [
+                    {"agent_id": ra.agent_id, "version_no": ra.version_no}
+                    for ra in request.related_agents
+                ]
+            else:
+                related_agents_dicts = [
+                    {"agent_id": aid, "version_no": None}
+                    for aid in related_agent_ids
+                ]
+
             update_related_agents(
                 parent_agent_id=agent_id,
-                related_agent_ids=related_agent_ids,
                 tenant_id=tenant_id,
-                user_id=user_id
+                user_id=user_id,
+                related_agents=related_agents_dicts,
             )
     except ValueError:
         # Re-raise ValueError (circular dependency) as-is
@@ -2287,12 +2370,13 @@ async def import_agent_impl(
             mapping_agent_id[need_import_agent_id] = new_agent_id
 
             agent_id_set.add(need_import_agent_id)
-            # Establish relationships with sub-agents
+            # Establish relationships with sub-agents - new sub-agents always use version 1
             for sub_agent_id in managed_agents:
                 insert_related_agent(parent_agent_id=mapping_agent_id[need_import_agent_id],
                                      child_agent_id=mapping_agent_id[sub_agent_id],
                                      tenant_id=tenant_id,
-                                     user_id=user_id)
+                                     user_id=user_id,
+                                     selected_agent_version_no=1)
         else:
             # Current agent still has sub-agents that haven't been imported
             agent_stack.append(need_import_agent_id)
diff --git a/backend/services/agent_version_service.py b/backend/services/agent_version_service.py
index fdaf7e89a..685d8f89a 100644
--- a/backend/services/agent_version_service.py
+++ b/backend/services/agent_version_service.py
@@ -825,7 +825,7 @@ async def list_published_agents_impl(
             _apply_duplicate_name_availability_rules,
         )
         from services.asset_owner_visibility import resolve_agent_list_permission
-        from database.agent_version_db import query_agent_snapshot
+        from database.agent_version_db import query_agent_snapshot, query_version_list
 
         # Get user role for permission check
         user_tenant_record = get_user_tenant_by_user_id(user_id) or {}
@@ -868,6 +868,21 @@ async def list_published_agents_impl(
             if not current_version_no or current_version_no <= 0:
                 continue
 
+            # Verify current_version_no exists, if not find the latest available version
+            available_versions = query_version_list(agent_id=agent_id, tenant_id=tenant_id)
+            
+            if not available_versions:
+                logger.warning(f"No available versions found for agent_id={agent_id}")
+                continue
+            
+            available_version_nos = {v["version_no"] for v in available_versions}
+            
+            if current_version_no not in available_version_nos:
+                logger.warning(
+                    f"Current version {current_version_no} not found for agent_id={agent_id}, using latest available version"
+                )
+                current_version_no = available_versions[0]["version_no"]
+
             # Get the published version snapshot
             agent_snapshot, tools_snapshot, relations_snapshot = query_agent_snapshot(
                 agent_id=agent_id,
@@ -889,6 +904,11 @@ async def list_published_agents_impl(
                 if key != 'current_version_no':
                     agent_info[key] = value
 
+            # Add version_name from version metadata
+            current_version_info = next((v for v in available_versions if v["version_no"] == current_version_no), None)
+            if current_version_info:
+                agent_info['version_name'] = current_version_info.get("version_name")
+
             # Add tools
             agent_info['tools'] = tools_snapshot
 
@@ -966,6 +986,7 @@ async def list_published_agents_impl(
                 "group_ids": agent.get("group_ids", []),
                 "permission": permission,
                 "current_version_no": agent.get("current_version_no"),
+                "version_name": agent.get("version_name"),
                 "greeting_message": agent.get("greeting_message"),
                 "example_questions": agent.get("example_questions"),
             })
diff --git a/frontend/app/[locale]/agents/components/agentConfig/CollaborativeAgent.tsx b/frontend/app/[locale]/agents/components/agentConfig/CollaborativeAgent.tsx
index d3090b369..240523047 100644
--- a/frontend/app/[locale]/agents/components/agentConfig/CollaborativeAgent.tsx
+++ b/frontend/app/[locale]/agents/components/agentConfig/CollaborativeAgent.tsx
@@ -18,6 +18,7 @@ export default function CollaborativeAgent() {
   const isCreatingMode = useAgentConfigStore((state) => state.isCreatingMode);
   const editedAgent = useAgentConfigStore((state) => state.editedAgent);
   const updateSubAgentIds = useAgentConfigStore((state) => state.updateSubAgentIds);
+  const updateSubAgentRelations = useAgentConfigStore((state) => state.updateSubAgentRelations);
   const updateExternalSubAgentIds = useAgentConfigStore((state) => state.updateExternalSubAgentIds);
 
   const { availableAgents: internalAgents } = usePublishedAgentList();
@@ -40,11 +41,61 @@ export default function CollaborativeAgent() {
   // Related internal agent IDs
   const relatedAgentIds = Array.isArray(editedAgent?.sub_agent_id_list) ? editedAgent.sub_agent_id_list : [];
 
-  // Related internal agents (from published list)
-  const relatedInternalAgents = (Array.isArray(internalAgents) ? internalAgents : []).filter(
-    (agent: Agent) => relatedAgentIds.includes(Number(agent.id))
+  // Map of agent_id -> saved version info (from snapshot)
+  const savedVersionMap = (() => {
+    const map: Record<number, { agent_name?: string | null; version_no: number | null; version_name?: string | null }> = {};
+    (editedAgent?.sub_agent_relations || []).forEach((rel) => {
+      map[rel.agent_id] = {
+        agent_name: rel.agent_name,
+        version_no: rel.version_no,
+        version_name: rel.version_name,
+      };
+    });
+    return map;
+  })();
+
+  // Related internal agents - display all agents from sub_agent_id_list
+  // For agents found in internalAgents, use full info (name, version)
+  // For legacy agents not found, still display with fallback info
+  const publishedAgentMap = new Map(
+    (Array.isArray(internalAgents) ? internalAgents : []).map((a: Agent) => [Number(a.id), a])
   );
 
+  const relatedInternalAgents = relatedAgentIds.map((agentId: number) => {
+    const publishedAgent = publishedAgentMap.get(Number(agentId));
+    const savedVersion = savedVersionMap[Number(agentId)];
+    const hasSavedVersion = savedVersion?.version_no != null;
+
+    if (publishedAgent) {
+      const version_name = (hasSavedVersion
+        ? (savedVersion?.version_name ?? publishedAgent.version_name)
+        : publishedAgent.version_name) ?? undefined;
+      const version_no = (hasSavedVersion
+        ? savedVersion?.version_no
+        : (publishedAgent as any).current_version_no) ?? undefined;
+      return {
+        ...publishedAgent,
+        version_name,
+        version_no,
+      };
+    }
+
+    // Legacy agent not found in published list - use name from sub_agent_relations
+    return {
+      id: String(agentId),
+      name: savedVersion?.agent_name || `Agent #${agentId}`,
+      display_name: savedVersion?.agent_name || `Agent #${agentId}`,
+      description: "",
+      model: "",
+      max_step: 0,
+      provide_run_summary: false,
+      tools: [],
+      skills: [],
+      version_name: savedVersion?.version_name ?? undefined,
+      version_no: savedVersion?.version_no ?? undefined,
+    } as Agent;
+  });
+
   // Available internal agents (exclude already related ones and current agent)
   const availableInternalAgents = (Array.isArray(internalAgents) ? internalAgents : []).filter(
     (agent: Agent) => !relatedAgentIds.includes(Number(agent.id)) && Number(agent.id) !== currentAgentId
@@ -82,6 +133,18 @@ export default function CollaborativeAgent() {
   const handleSelectInternalAgent = (agentId: number) => {
     const newRelatedAgentIds = [...(Array.isArray(relatedAgentIds) ? relatedAgentIds : []), agentId];
     updateSubAgentIds(newRelatedAgentIds);
+
+    // Sync sub_agent_relations: add new agent with its current published version_no
+    const selectedAgent = (Array.isArray(internalAgents) ? internalAgents : []).find(
+      (a: Agent) => Number(a.id) === agentId
+    );
+    const currentVersionNo = selectedAgent?.current_version_no ?? null;
+    const existingRelations = editedAgent?.sub_agent_relations || [];
+    const newRelations = [
+      ...existingRelations,
+      { agent_id: agentId, version_no: currentVersionNo, version_name: selectedAgent?.version_name },
+    ];
+    updateSubAgentRelations(newRelations);
   };
 
   // Add external agent
@@ -108,6 +171,13 @@ export default function CollaborativeAgent() {
       (id: number) => id !== agentId
     );
     updateSubAgentIds(newRelatedAgentIds);
+
+    // Sync sub_agent_relations: remove the agent
+    const existingRelations = editedAgent?.sub_agent_relations || [];
+    const newRelations = existingRelations.filter(
+      (rel: { agent_id: number; version_no: number | null; version_name?: string }) => rel.agent_id !== agentId
+    );
+    updateSubAgentRelations(newRelations);
   };
 
   // Remove external agent
@@ -129,35 +199,67 @@ export default function CollaborativeAgent() {
   };
 
   // Unified dropdown menu items
-  const dropdownMenuItems = [
-    // Internal agents group
-    {
-      key: "internal",
-      type: "group" as const,
-      label: t("collaborativeAgent.internalAgents"),
-      children: availableInternalAgents.map((agent: Agent) => ({
-        key: `internal-${agent.id}`,
-        label: agent.display_name || agent.name,
-        onClick: () => handleSelectInternalAgent(Number(agent.id)),
-      })),
-    },
-    // External A2A agents group
-    {
-      key: "external",
-      type: "group" as const,
-      label: t("collaborativeAgent.externalAgents"),
-      children: availableExternalForSelection.map((agent: A2AExternalAgent) => ({
-        key: `external-${agent.id}`,
+  const internalMenuItems = availableInternalAgents.map((agent: Agent) => ({
+    key: `internal-${agent.id}`,
+    label: (
+      <div className="flex items-center justify-between w-full">
+        <span>{agent.display_name || agent.name}</span>
+        {agent.version_name && (
+          <span className="text-xs text-gray-400 ml-2">{agent.version_name}</span>
+        )}
+      </div>
+    ),
+    onClick: () => handleSelectInternalAgent(Number(agent.id)),
+  }));
+
+  const externalMenuItems = availableExternalForSelection.map((agent: A2AExternalAgent) => ({
+    key: `external-${agent.id}`,
+    label: (
+      <div className="flex items-center justify-between w-full">
+        <span className="flex items-center gap-2">
+          <Globe size={12} />
+          {agent.name}
+        </span>
+        {agent.version && (
+          <span className="text-xs text-gray-400 ml-2">v{agent.version}</span>
+        )}
+      </div>
+    ),
+    onClick: () => handleSelectExternalAgent(agent.id),
+  }));
+
+  const hasInternal = internalMenuItems.length > 0;
+  const hasExternal = externalMenuItems.length > 0;
+
+  const dropdownMenuItems = (() => {
+    if (!hasInternal && !hasExternal) {
+      return [{
+        key: "no-agents",
+        disabled: true,
         label: (
-          <span className="flex items-center gap-2">
-            <Globe size={12} />
-            {agent.name}
-          </span>
+          <span className="text-gray-400">{t("collaborativeAgent.noAgents")}</span>
         ),
-        onClick: () => handleSelectExternalAgent(agent.id),
-      })),
-    },
-  ];
+      }];
+    }
+    const items: any[] = [];
+    if (hasInternal) {
+      items.push({
+        key: "internal",
+        type: "group" as const,
+        label: t("collaborativeAgent.internalAgents"),
+        children: internalMenuItems,
+      });
+    }
+    if (hasExternal) {
+      items.push({
+        key: "external",
+        type: "group" as const,
+        label: t("collaborativeAgent.externalAgents"),
+        children: externalMenuItems,
+      });
+    }
+    return items;
+  })();
 
   return (
     <>
@@ -169,6 +271,7 @@ export default function CollaborativeAgent() {
             menu={{ items: dropdownMenuItems }}
             disabled={isReadOnly}
             trigger={["click"]}
+            styles={{ root: { maxHeight: '400px', overflowY: 'auto' } }}
           >
             <div className="flex items-center shrink-0">
               <Button
@@ -189,9 +292,14 @@ export default function CollaborativeAgent() {
                   key={`internal-${agent.id}`}
                   closable={!isReadOnly}
                   onClose={!isReadOnly ? () => handleRemoveInternalAgent(Number(agent.id)) : undefined}
-                  className="bg-blue-50 text-blue-700 border-blue-200"
+                  className="!inline-flex !items-center !whitespace-nowrap !py-1.5 !px-3 !text-sm !bg-blue-50 !text-blue-700 !border !border-blue-200 !rounded-lg !shadow-sm hover:!shadow-md hover:!border-blue-400 transition-all"
                 >
-                  {agent.display_name || agent.name}
+                  <span className="inline-flex items-center gap-1.5">
+                    <span className="font-medium">{agent.display_name || agent.name}</span>
+                    {agent.version_name && (
+                      <span className="text-xs text-blue-500 bg-blue-100 px-1.5 py-0.5 rounded">{agent.version_name}</span>
+                    )}
+                  </span>
                 </Tag>
               ))}
               </Flex>
@@ -205,11 +313,11 @@ export default function CollaborativeAgent() {
                   key={`external-${agent.id}`}
                   closable={!isReadOnly}
                   onClose={!isReadOnly ? () => handleRemoveExternalAgent(agent.id) : undefined}
-                  className="bg-green-50 text-green-700 border-green-200"
+                  className="!inline-flex !items-center !whitespace-nowrap !py-1.5 !px-3 !text-sm !bg-green-50 !text-green-700 !border !border-green-200 !rounded-lg !shadow-sm hover:!shadow-md hover:!border-green-400 transition-all"
                 >
-                  <span className="inline-flex items-center gap-1">
-                    <Globe size={12} />
-                    {agent.name}
+                  <span className="inline-flex items-center gap-1.5">
+                    <Globe size={14} />
+                    <span className="font-medium">{agent.name}</span>
                   </span>
                 </Tag>
               ))}
diff --git a/frontend/hooks/agent/useSaveGuard.ts b/frontend/hooks/agent/useSaveGuard.ts
index a6fa3e42b..6d4d5b188 100644
--- a/frontend/hooks/agent/useSaveGuard.ts
+++ b/frontend/hooks/agent/useSaveGuard.ts
@@ -185,6 +185,17 @@ export const useSaveGuard = () => {
         .map((id: any) => Number(id))
         .filter((id: number) => Number.isFinite(id));
 
+      // Build related_agents directly from sub_agent_relations.
+      // sub_agent_relations is kept in sync by CollaborativeAgent when adding/removing:
+      // - Newly selected agents get their current_version_no from the published list
+      // - Already saved agents retain their original version_no
+      const relatedAgents = (currentEditedAgent.sub_agent_relations || [])
+        .filter((rel: any) => rel?.agent_id != null && Number.isFinite(Number(rel.agent_id)))
+        .map((rel: any) => ({
+          agent_id: Number(rel.agent_id),
+          version_no: rel.version_no != null ? Number(rel.version_no) : 0,
+        }));
+
       const relatedExternalAgentIds = (
         currentEditedAgent.external_sub_agent_id_list || []
       )
@@ -259,6 +270,7 @@ export const useSaveGuard = () => {
         enabled_skill_ids: enabledSkillIds,
         skill_instances: skillInstances,
         related_agent_ids: relatedAgentIds,
+        related_agents: relatedAgents,
         related_external_agent_ids: relatedExternalAgentIds,
         ingroup_permission:
           currentEditedAgent.ingroup_permission ?? "READ_ONLY",
diff --git a/frontend/public/locales/en/common.json b/frontend/public/locales/en/common.json
index 1fbf71d4f..35ab20466 100644
--- a/frontend/public/locales/en/common.json
+++ b/frontend/public/locales/en/common.json
@@ -3733,6 +3733,7 @@
   "a2a.service.chatFailed": "Failed to send chat message",
   "collaborativeAgent.internalAgents": "Internal Agents",
   "collaborativeAgent.externalAgents": "External Agents",
+  "collaborativeAgent.noAgents": "No agents available",
   "collaborativeAgent.addExternal": "Add External Agent",
   "skillSpace.comingSoon.title": "Skill Space Coming Soon",
   "skillSpace.comingSoon.description": "A powerful marketplace to discover, install, and manage AI skills for your agents. Extend capabilities with pre-built skill packs.",
diff --git a/frontend/public/locales/zh/common.json b/frontend/public/locales/zh/common.json
index f78bb46df..83d40ccce 100644
--- a/frontend/public/locales/zh/common.json
+++ b/frontend/public/locales/zh/common.json
@@ -3616,6 +3616,7 @@
   "a2a.service.chatFailed": "发送聊天消息失败",
   "collaborativeAgent.internalAgents": "内部 Agent",
   "collaborativeAgent.externalAgents": "外部 Agent",
+  "collaborativeAgent.noAgents": "暂无智能体",
   "collaborativeAgent.addExternal": "添加外部 Agent",
   "systemPrompt.button.optimize": "优化",
   "systemPrompt.optimize.feedbackLabel": "评价反馈",
diff --git a/frontend/services/agentConfigService.ts b/frontend/services/agentConfigService.ts
index 73dc45809..63b4d4e13 100644
--- a/frontend/services/agentConfigService.ts
+++ b/frontend/services/agentConfigService.ts
@@ -217,6 +217,7 @@ export const fetchPublishedAgentList = async () => {
       is_new: agent.is_new || false,
       permission: agent.permission,
       current_version_no: agent.current_version_no,
+      version_name: agent.version_name,
       greeting_message: agent.greeting_message,
       example_questions: agent.example_questions || [],
     }));
@@ -443,6 +444,7 @@ export interface UpdateAgentInfoPayload {
     config_values?: Record<string, unknown>;
   }>;
   related_agent_ids?: number[];
+  related_agents?: { agent_id: number; version_no: number }[];
   related_external_agent_ids?: number[];
   ingroup_permission?: string;
   greeting_message?: string;
@@ -826,7 +828,8 @@ export const searchAgentInfo = async (
       enabled: data.enabled,
       is_available: data.is_available,
       unavailable_reasons: data.unavailable_reasons || [],
-      sub_agent_id_list: data.sub_agent_id_list || [],
+      sub_agent_id_list: data.sub_agent_id_list || [], // Add sub_agent_id_list
+      sub_agent_relations: data.sub_agent_relations || [],
       external_sub_agent_id_list: data.external_sub_agent_id_list || [],
       group_ids: data.group_ids || [],
       ingroup_permission: data.ingroup_permission || "READ_ONLY",
diff --git a/frontend/stores/agentConfigStore.ts b/frontend/stores/agentConfigStore.ts
index 5e7ebf7dc..a1706f1d6 100644
--- a/frontend/stores/agentConfigStore.ts
+++ b/frontend/stores/agentConfigStore.ts
@@ -50,6 +50,7 @@ export type EditableAgent = Pick<
   | "prompt_template_name"
   | "verification_config"
   | "sub_agent_id_list"
+  | "sub_agent_relations"
   | "group_ids"
   | "ingroup_permission"
   | "enable_context_manager"
@@ -115,6 +116,11 @@ interface AgentConfigStoreState {
    */
   updateSubAgentIds: (ids: number[]) => void;
 
+  /**
+   * Update sub_agent_relations (synced with sub_agent_id_list).
+   */
+  updateSubAgentRelations: (relations: Array<{ agent_id: number; version_no: number | null; version_name?: string }>) => void;
+
   /**
    * Update external_sub_agent_id_list.
    */
@@ -201,6 +207,7 @@ function createEmptyEditableAgent(llmConfig?: { id: number | null; name: string;
       guardrail_config: { ...DEFAULT_GUARDRAIL_CONFIG },
     },
     sub_agent_id_list: [],
+    sub_agent_relations: [],
     group_ids: [],
     ingroup_permission: "READ_ONLY",
     greeting_message: "",
@@ -236,6 +243,7 @@ const toEditable = (agent: Agent | null): EditableAgent =>
         prompt_template_name: agent.prompt_template_name || "system_default",
         verification_config: agent.verification_config || { ...DEFAULT_AGENT_VERIFICATION_CONFIG },
         sub_agent_id_list: agent.sub_agent_id_list || [],
+        sub_agent_relations: agent.sub_agent_relations || [],
         external_sub_agent_id_list: agent.external_sub_agent_id_list || [],
         group_ids: agent.group_ids || [],
         ingroup_permission: agent.ingroup_permission || "READ_ONLY",
@@ -507,6 +515,14 @@ export const useAgentConfigStore = create<AgentConfigStoreState>((set, get) => (
     });
   },
 
+  updateSubAgentRelations: (relations) => {
+    set((state) => {
+      const editedAgent = { ...state.editedAgent, sub_agent_relations: relations };
+      const hasUnsavedChanges = isDirty(state.baselineAgent, editedAgent);
+      return { editedAgent, hasUnsavedChanges };
+    });
+  },
+
   updateExternalSubAgentIds: (ids) => {
     set((state) => {
       const editedAgent = { ...state.editedAgent, external_sub_agent_id_list: ids };
diff --git a/frontend/types/agentConfig.ts b/frontend/types/agentConfig.ts
index eb7b495a1..fc13ae7c6 100644
--- a/frontend/types/agentConfig.ts
+++ b/frontend/types/agentConfig.ts
@@ -161,6 +161,7 @@ export interface Agent {
   is_available?: boolean;
   is_new?: boolean;
   sub_agent_id_list?: number[];
+  sub_agent_relations?: Array<{ agent_id: number; agent_name?: string; version_no: number | null; version_name?: string }>;
   external_sub_agent_id_list?: number[]; // External A2A agent IDs
   group_ids?: number[];
   ingroup_permission?: "EDIT" | "READ_ONLY" | "PRIVATE";
@@ -172,6 +173,7 @@ export interface Agent {
   /** When true, system prompts were withheld (ASSET_OWNER agent viewed by non-ASSET_OWNER caller). */
   prompts_hidden?: boolean;
   current_version_no?: number;
+  version_name?: string;
   is_a2a_server?: boolean;
   greeting_message?: string;
   example_questions?: string[];
diff --git a/test/backend/database/test_agent_db.py b/test/backend/database/test_agent_db.py
index 8dfcf8a2a..bb07ffe43 100644
--- a/test/backend/database/test_agent_db.py
+++ b/test/backend/database/test_agent_db.py
@@ -102,7 +102,8 @@
     insert_related_agent,
     delete_related_agent,
     delete_agent_relationship,
-    update_related_agents
+    update_related_agents,
+    batch_search_agent_display_names,
 )
 
 class MockAgent:
@@ -689,7 +690,7 @@ def __init__(self, **kwargs):
     monkeypatch.setattr("backend.database.agent_db.AgentRelation", MockAgentRelationClass)
 
     # Execute - add new relations [2, 3]
-    update_related_agents(1, [2, 3], "tenant1", "user1")
+    update_related_agents(1, "tenant1", "user1", related_agents=[{"agent_id": 2}, {"agent_id": 3}])
 
     # Verify: should add 2 new relations, no deletions
     assert session.add.call_count == 2
@@ -732,7 +733,7 @@ def test_update_related_agents_delete_existing(monkeypatch, mock_session):
     monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
 
     # Execute - remove all relations (empty list)
-    update_related_agents(1, [], "tenant1", "user1")
+    update_related_agents(1, "tenant1", "user1", related_agents=[])
 
     # Verify: should soft delete 2 relations, add none
     mock_update.assert_called_once()
@@ -790,7 +791,7 @@ def __init__(self, **kwargs):
     monkeypatch.setattr("backend.database.agent_db.AgentRelation", MockAgentRelationClass)
 
     # Execute - replace [2, 3] with [3, 4] (delete 2, add 4)
-    update_related_agents(1, [3, 4], "tenant1", "user1")
+    update_related_agents(1, "tenant1", "user1", related_agents=[{"agent_id": 3}, {"agent_id": 4}])
 
     # Verify: should delete 2 (relation with selected_agent_id=2), add 4
     mock_update.assert_called_once()
@@ -825,7 +826,7 @@ def test_update_related_agents_no_changes(monkeypatch, mock_session):
     monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
 
     # Execute - same relations [2, 3]
-    update_related_agents(1, [2, 3], "tenant1", "user1")
+    update_related_agents(1, "tenant1", "user1", related_agents=[{"agent_id": 2}, {"agent_id": 3}])
 
     # Verify: no deletions, no additions
     session.add.assert_not_called()
@@ -986,3 +987,402 @@ def test_clear_agent_new_mark_database_connection_error(monkeypatch):
     # Execute and expect exception
     with pytest.raises(Exception):
         clear_agent_new_mark(1, "tenant1", "user1")
+
+
+# ===================== batch_search_agent_display_names tests =====================
+
+
+def test_batch_search_agent_display_names_empty_list(monkeypatch):
+    """Test batch_search_agent_display_names with empty agent_ids returns empty dict."""
+    result = batch_search_agent_display_names(agent_ids=[], tenant_id="tenant1")
+    assert result == {}
+
+
+def test_batch_search_agent_display_names_success(monkeypatch, mock_session):
+    """Test batch_search_agent_display_names returns mapping of agent_id -> display_name."""
+    session, query = mock_session
+
+    mock_agent1 = MagicMock()
+    mock_agent1.agent_id = 1
+    mock_agent1.display_name = "Agent One"
+    mock_agent1.name = "agent_one"
+
+    mock_agent2 = MagicMock()
+    mock_agent2.agent_id = 2
+    mock_agent2.display_name = None
+    mock_agent2.name = "agent_two"
+
+    mock_all = MagicMock()
+    mock_all.return_value = [mock_agent1, mock_agent2]
+    mock_filter = MagicMock()
+    mock_filter.all = mock_all
+    query.filter.return_value = mock_filter
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
+
+    result = batch_search_agent_display_names(agent_ids=[1, 2], tenant_id="tenant1")
+
+    assert result == {1: "Agent One", 2: "agent_two"}
+
+
+# ===================== insert_related_agent with selected_agent_version_no tests =====================
+
+
+def test_insert_related_agent_with_selected_agent_version_no(monkeypatch, mock_session):
+    """Test insert_related_agent passes selected_agent_version_no to the relation."""
+    session, query = mock_session
+    session.add = MagicMock()
+    session.flush = MagicMock()
+
+    captured_kwargs = {}
+    def mock_agent_relation_init(**kwargs):
+        captured_kwargs.update(kwargs)
+        return MagicMock()
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.agent_db.filter_property", lambda data, model: data)
+    monkeypatch.setattr("backend.database.agent_db.AgentRelation", mock_agent_relation_init)
+
+    result = insert_related_agent(1, 2, "tenant1", "user1", selected_agent_version_no=5)
+
+    assert result is True
+    assert captured_kwargs["selected_agent_version_no"] == 5
+    session.add.assert_called_once()
+
+
+def test_insert_related_agent_without_selected_agent_version_no(monkeypatch, mock_session):
+    """Test insert_related_agent defaults selected_agent_version_no to None."""
+    session, query = mock_session
+    session.add = MagicMock()
+    session.flush = MagicMock()
+
+    captured_kwargs = {}
+    def mock_agent_relation_init(**kwargs):
+        captured_kwargs.update(kwargs)
+        return MagicMock()
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.agent_db.filter_property", lambda data, model: data)
+    monkeypatch.setattr("backend.database.agent_db.AgentRelation", mock_agent_relation_init)
+
+    result = insert_related_agent(1, 2, "tenant1", "user1")
+
+    assert result is True
+    assert captured_kwargs["selected_agent_version_no"] is None
+
+
+# ===================== update_related_agents version update tests =====================
+
+
+def test_update_related_agents_updates_version_no(monkeypatch, mock_session):
+    """Test update_related_agents updates selected_agent_version_no for existing relations."""
+    session, query = mock_session
+
+    # Mock existing relation with old version
+    mock_relation = MockAgentRelation()
+    mock_relation.selected_agent_id = 2
+    mock_relation.selected_agent_version_no = 1
+    mock_relation.relation_id = 10
+
+    mock_all = MagicMock()
+    mock_all.return_value = [mock_relation]
+    mock_filter1 = MagicMock()
+    mock_filter1.all = mock_all
+    query.filter.return_value = mock_filter1
+
+    session.add = MagicMock()
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.agent_db.filter_property", lambda data, model: data)
+
+    # Execute - update relation for agent 2 with new version_no=3
+    update_related_agents(1, "tenant1", "user1", related_agents=[{"agent_id": 2, "version_no": 3}])
+
+    # Verify: no deletions, no additions, version_no updated
+    session.add.assert_not_called()
+    assert mock_relation.selected_agent_version_no == 3
+    assert mock_relation.updated_by == "user1"
+
+
+def test_update_related_agents_no_version_no_keeps_existing(monkeypatch, mock_session):
+    """Test update_related_agents does not update when version_no is None in related_agents."""
+    session, query = mock_session
+
+    mock_relation = MockAgentRelation()
+    mock_relation.selected_agent_id = 2
+    mock_relation.selected_agent_version_no = 5
+    mock_relation.relation_id = 10
+
+    mock_all = MagicMock()
+    mock_all.return_value = [mock_relation]
+    mock_filter1 = MagicMock()
+    mock_filter1.all = mock_all
+    query.filter.return_value = mock_filter1
+
+    session.add = MagicMock()
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
+
+    # Execute - related_agents has agent_id=2 but version_no=None
+    update_related_agents(1, "tenant1", "user1", related_agents=[{"agent_id": 2, "version_no": None}])
+
+    # Verify: version_no should remain unchanged
+    assert mock_relation.selected_agent_version_no == 5
+
+
+def test_update_related_agents_with_none_related_agents(monkeypatch, mock_session):
+    """Test update_related_agents with related_agents=None deletes all existing relations."""
+    session, query = mock_session
+
+    mock_relation = MockAgentRelation()
+    mock_relation.selected_agent_id = 2
+
+    mock_all = MagicMock()
+    mock_all.return_value = [mock_relation]
+    mock_filter1 = MagicMock()
+    mock_filter1.all = mock_all
+
+    mock_update = MagicMock()
+    mock_filter2 = MagicMock()
+    mock_filter2.update = mock_update
+
+    query.filter.side_effect = [mock_filter1, mock_filter2]
+
+    session.add = MagicMock()
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
+
+    # Execute - related_agents=None means no new relations
+    update_related_agents(1, "tenant1", "user1", related_agents=None)
+
+    # Verify: should soft delete the existing relation
+    mock_update.assert_called_once()
+    session.add.assert_not_called()
+
+
+# ===================== _parse_related_agents tests =====================
+
+
+def test_parse_related_agents_none():
+    """Test _parse_related_agents with None input returns empty sets."""
+    from backend.database.agent_db import _parse_related_agents
+    ids, version_map = _parse_related_agents(None)
+    assert ids == set()
+    assert version_map == {}
+
+
+def test_parse_related_agents_empty_list():
+    """Test _parse_related_agents with empty list returns empty sets."""
+    from backend.database.agent_db import _parse_related_agents
+    ids, version_map = _parse_related_agents([])
+    assert ids == set()
+    assert version_map == {}
+
+
+def test_parse_related_agents_with_none_agent_id():
+    """Test _parse_related_agents skips entries with agent_id=None."""
+    from backend.database.agent_db import _parse_related_agents
+    ids, version_map = _parse_related_agents([
+        {"agent_id": None, "version_no": 1},
+        {"agent_id": 2, "version_no": 3},
+    ])
+    assert ids == {2}
+    assert version_map == {2: 3}
+
+
+def test_parse_related_agents_with_none_version_no():
+    """Test _parse_related_agents does not add None version_no to version_map."""
+    from backend.database.agent_db import _parse_related_agents
+    ids, version_map = _parse_related_agents([
+        {"agent_id": 1, "version_no": None},
+        {"agent_id": 2, "version_no": 5},
+    ])
+    assert ids == {1, 2}
+    assert version_map == {2: 5}
+
+
+def test_parse_related_agents_normal_case():
+    """Test _parse_related_agents with normal input."""
+    from backend.database.agent_db import _parse_related_agents
+    ids, version_map = _parse_related_agents([
+        {"agent_id": 1, "version_no": 2},
+        {"agent_id": 3, "version_no": 4},
+        {"agent_id": 5, "version_no": None},
+    ])
+    assert ids == {1, 3, 5}
+    assert version_map == {1: 2, 3: 4}
+
+
+# ===================== _add_new_relations with version_map tests =====================
+
+
+def test_add_new_relations_with_version_map(monkeypatch, mock_session):
+    """Test _add_new_relations sets selected_agent_version_no from version_map."""
+    session, query = mock_session
+    session.add = MagicMock()
+
+    captured_relations = []
+    class MockAgentRelationClass:
+        def __init__(self, **kwargs):
+            captured_relations.append(kwargs)
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.filter_property", lambda data, model: data)
+    monkeypatch.setattr("backend.database.agent_db.AgentRelation", MockAgentRelationClass)
+
+    from backend.database.agent_db import _add_new_relations
+    _add_new_relations(
+        session=session,
+        parent_agent_id=1,
+        tenant_id="tenant1",
+        user_id="user1",
+        version_no=0,
+        ids_to_add={2, 3},
+        version_map={2: 5},
+    )
+
+    assert len(captured_relations) == 2
+    # Relation for agent 2 should have selected_agent_version_no=5
+    rel_2 = next(r for r in captured_relations if r["selected_agent_id"] == 2)
+    assert rel_2["selected_agent_version_no"] == 5
+    # Relation for agent 3 should not have selected_agent_version_no
+    rel_3 = next(r for r in captured_relations if r["selected_agent_id"] == 3)
+    assert "selected_agent_version_no" not in rel_3
+
+
+# ===================== update_agent with model_fields_set tests =====================
+
+
+def test_update_agent_pops_requested_output_tokens_when_not_in_fields_set(monkeypatch, mock_session):
+    """Test update_agent pops requested_output_tokens when model_fields_set doesn't include it."""
+    session, query = mock_session
+    mock_agent = MockAgent()
+    mock_agent.requested_output_tokens = 2048
+
+    mock_first = MagicMock()
+    mock_first.return_value = mock_agent
+    mock_filter = MagicMock()
+    mock_filter.first = mock_first
+    query.filter.return_value = mock_filter
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.agent_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.agent_db.filter_property", lambda data, model: data)
+
+    class AgentInfoUpdate:
+        def __init__(self):
+            self.name = "updated_name"
+            # model_fields_set exists but does NOT contain "requested_output_tokens"
+            self.model_fields_set = {"name"}
+
+    agent_info = AgentInfoUpdate()
+
+    update_agent(1, agent_info, "user1")
+
+    # requested_output_tokens should be popped from agent_data, so it's not set on mock_agent
+    assert mock_agent.name == "updated_name"
+    assert mock_agent.updated_by == "user1"
+
+
+# ===================== _update_existing_relations direct tests =====================
+
+
+def test_update_existing_relations_skips_none_version_no(monkeypatch):
+    """Test _update_existing_relations skips update when new_version_no is None for some relations."""
+    from backend.database.agent_db import _update_existing_relations
+
+    mock_rel_with_version = MagicMock()
+    mock_rel_with_version.selected_agent_id = 2
+    mock_rel_with_version.selected_agent_version_no = 1
+
+    mock_rel_without_version = MagicMock()
+    mock_rel_without_version.selected_agent_id = 5
+    mock_rel_without_version.selected_agent_version_no = 10
+
+    # version_map only has agent 2, not agent 5
+    _update_existing_relations(
+        current_relations=[mock_rel_with_version, mock_rel_without_version],
+        ids_to_update={2, 5},
+        version_map={2: 3},
+        user_id="user1",
+    )
+
+    # Agent 2 should be updated to version 3
+    assert mock_rel_with_version.selected_agent_version_no == 3
+    assert mock_rel_with_version.updated_by == "user1"
+    # Agent 5 should NOT be updated (new_version_no is None)
+    assert mock_rel_without_version.selected_agent_version_no == 10
+
+
+def test_update_existing_relations_skips_relations_not_in_update_set(monkeypatch):
+    """Test _update_existing_relations skips relations not in ids_to_update."""
+    from backend.database.agent_db import _update_existing_relations
+
+    mock_rel_to_update = MagicMock()
+    mock_rel_to_update.selected_agent_id = 2
+    mock_rel_to_update.selected_agent_version_no = 1
+
+    mock_rel_to_skip = MagicMock()
+    mock_rel_to_skip.selected_agent_id = 99
+    mock_rel_to_skip.selected_agent_version_no = 7
+
+    _update_existing_relations(
+        current_relations=[mock_rel_to_update, mock_rel_to_skip],
+        ids_to_update={2},
+        version_map={2: 5},
+        user_id="user1",
+    )
+
+    # Agent 2 should be updated
+    assert mock_rel_to_update.selected_agent_version_no == 5
+    # Agent 99 should NOT be updated (not in ids_to_update)
+    assert mock_rel_to_skip.selected_agent_version_no == 7
+
+
+def test_update_existing_relations_returns_early_when_empty():
+    """Test _update_existing_relations returns early when ids_to_update or version_map is empty."""
+    from backend.database.agent_db import _update_existing_relations
+
+    mock_rel = MagicMock()
+    mock_rel.selected_agent_id = 2
+    mock_rel.selected_agent_version_no = 1
+
+    # Empty ids_to_update
+    _update_existing_relations(
+        current_relations=[mock_rel],
+        ids_to_update=set(),
+        version_map={2: 3},
+        user_id="user1",
+    )
+    assert mock_rel.selected_agent_version_no == 1  # unchanged
+
+    # Empty version_map
+    _update_existing_relations(
+        current_relations=[mock_rel],
+        ids_to_update={2},
+        version_map={},
+        user_id="user1",
+    )
+    assert mock_rel.selected_agent_version_no == 1  # unchanged
diff --git a/test/backend/database/test_agent_version_db.py b/test/backend/database/test_agent_version_db.py
index 2ded592e6..1c425cbca 100644
--- a/test/backend/database/test_agent_version_db.py
+++ b/test/backend/database/test_agent_version_db.py
@@ -92,6 +92,8 @@
     insert_skill_snapshot,
     get_next_version_no,
     delete_version,
+    batch_search_version_names,
+    batch_query_current_version_nos,
     SOURCE_TYPE_NORMAL,
     SOURCE_TYPE_ROLLBACK,
     STATUS_RELEASED,
@@ -1545,3 +1547,83 @@ def test_delete_skill_snapshot_not_found(monkeypatch, mock_session):
     )
 
     assert result == 0
+
+
+# ===================== batch_search_version_names tests =====================
+
+
+def test_batch_search_version_names_empty_inputs(monkeypatch):
+    """Test batch_search_version_names with empty lists returns empty list."""
+    assert batch_search_version_names(agent_ids=[], tenant_id="tenant1", version_nos=[]) == []
+    assert batch_search_version_names(agent_ids=[1], tenant_id="tenant1", version_nos=[]) == []
+    assert batch_search_version_names(agent_ids=[], tenant_id="tenant1", version_nos=[1]) == []
+
+
+def test_batch_search_version_names_success(monkeypatch, mock_session):
+    """Test batch_search_version_names returns list of dicts with version info."""
+    session, query = mock_session
+
+    mock_v1 = MagicMock()
+    mock_v1.agent_id = 1
+    mock_v1.version_no = 2
+    mock_v1.version_name = "v2.0"
+
+    mock_v2 = MagicMock()
+    mock_v2.agent_id = 3
+    mock_v2.version_no = 1
+    mock_v2.version_name = None
+
+    mock_all = MagicMock()
+    mock_all.return_value = [mock_v1, mock_v2]
+    mock_filter = MagicMock()
+    mock_filter.all = mock_all
+    query.filter.return_value = mock_filter
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr(agent_version_db_module, "get_db_session", lambda: mock_ctx)
+
+    result = batch_search_version_names(agent_ids=[1, 3], tenant_id="tenant1", version_nos=[1, 2])
+
+    assert len(result) == 2
+    assert result[0] == {"agent_id": 1, "version_no": 2, "version_name": "v2.0"}
+    assert result[1] == {"agent_id": 3, "version_no": 1, "version_name": None}
+
+
+# ===================== batch_query_current_version_nos tests =====================
+
+
+def test_batch_query_current_version_nos_empty_list(monkeypatch):
+    """Test batch_query_current_version_nos with empty agent_ids returns empty dict."""
+    result = batch_query_current_version_nos(agent_ids=[], tenant_id="tenant1")
+    assert result == {}
+
+
+def test_batch_query_current_version_nos_success(monkeypatch, mock_session):
+    """Test batch_query_current_version_nos returns mapping of agent_id -> current_version_no."""
+    session, query = mock_session
+
+    mock_a1 = MagicMock()
+    mock_a1.agent_id = 1
+    mock_a1.current_version_no = 3
+
+    mock_a2 = MagicMock()
+    mock_a2.agent_id = 2
+    mock_a2.current_version_no = None  # Should be filtered out
+
+    mock_all = MagicMock()
+    mock_all.return_value = [mock_a1, mock_a2]
+    mock_filter = MagicMock()
+    mock_filter.all = mock_all
+    query.filter.return_value = mock_filter
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr(agent_version_db_module, "get_db_session", lambda: mock_ctx)
+
+    result = batch_query_current_version_nos(agent_ids=[1, 2], tenant_id="tenant1")
+
+    # Agent 2 should be filtered out because current_version_no is None
+    assert result == {1: 3}
diff --git a/test/backend/services/test_agent_service.py b/test/backend/services/test_agent_service.py
index a183ff449..d2d80ab74 100644
--- a/test/backend/services/test_agent_service.py
+++ b/test/backend/services/test_agent_service.py
@@ -429,6 +429,8 @@ def apply_default_prompt_template_request_fields(request, prompt_template_id=Non
     request.enabled_skill_ids = None
     if not hasattr(request, "related_agent_ids"):
         request.related_agent_ids = None
+    if not hasattr(request, "related_agents"):
+        request.related_agents = None
     if not hasattr(request, "enabled_tool_ids"):
         request.enabled_tool_ids = None
     if not hasattr(request, "example_questions"):
@@ -586,6 +588,7 @@ async def test_get_agent_info_impl_success(mock_search_agent_info, mock_search_t
         "business_description": "Test agent",
         "tools": expected_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [{"skill_id": 1, "enabled": True}],
         "external_sub_agent_id_list": [],
         "model_ids": [],  # Added for get_valid_model_ids integration
@@ -665,6 +668,7 @@ async def test_get_agent_info_impl_with_version_no(mock_search_agent_info, mock_
         "business_description": "Test agent",
         "tools": expected_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [],
         "external_sub_agent_id_list": [],
         "model_ids": [],  # Added for get_valid_model_ids integration
@@ -1066,6 +1070,7 @@ async def test_update_agent_info_impl_with_related_agent_ids(
     request.agent_id = 123
     request.enabled_tool_ids = None
     request.related_agent_ids = [456, 789]
+    request.related_agents = None
     apply_default_prompt_template_request_fields(request)
 
     # Execute
@@ -1076,9 +1081,9 @@ async def test_update_agent_info_impl_with_related_agent_ids(
     mock_update_agent.assert_called_once()
     mock_update_related_agents.assert_called_once_with(
         parent_agent_id=123,
-        related_agent_ids=[456, 789],
         tenant_id="test_tenant",
-        user_id="test_user"
+        user_id="test_user",
+        related_agents=[{"agent_id": 456, "version_no": None}, {"agent_id": 789, "version_no": None}],
     )
 
 
@@ -1151,6 +1156,7 @@ async def test_update_agent_info_impl_with_both_tool_and_related_agents(
     request.agent_id = 123
     request.enabled_tool_ids = [1]
     request.related_agent_ids = [456]
+    request.related_agents = None
     apply_default_prompt_template_request_fields(request)
 
     # Execute
@@ -1162,9 +1168,9 @@ async def test_update_agent_info_impl_with_both_tool_and_related_agents(
     mock_create_or_update_tool.assert_called_once()
     mock_update_related_agents.assert_called_once_with(
         parent_agent_id=123,
-        related_agent_ids=[456],
         tenant_id="test_tenant",
-        user_id="test_user"
+        user_id="test_user",
+        related_agents=[{"agent_id": 456, "version_no": None}],
     )
 
 
@@ -1227,6 +1233,7 @@ async def test_update_agent_info_impl_related_agent_update_exception(
     request.agent_id = 123
     request.enabled_tool_ids = None
     request.related_agent_ids = [456]
+    request.related_agents = None
     apply_default_prompt_template_request_fields(request)
 
     # Execute & Assert
@@ -1789,6 +1796,7 @@ async def test_get_agent_info_impl_with_model_id_success(mock_search_agent_info,
         "business_description": "Test agent",
         "tools": mock_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [],
         "external_sub_agent_id_list": [],
         "model_name": "GPT-4",
@@ -1895,6 +1903,7 @@ async def test_get_agent_info_impl_with_model_id_no_display_name(mock_search_age
         "business_description": "Test agent",
         "tools": mock_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [],
         "external_sub_agent_id_list": [],
         "model_names": [],
@@ -1965,6 +1974,7 @@ async def test_get_agent_info_impl_with_model_id_none_model_info(mock_search_age
         "business_description": "Test agent",
         "tools": mock_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [],
         "external_sub_agent_id_list": [],
         "model_names": [],
@@ -2059,6 +2069,7 @@ def mock_get_model(model_id):
         "business_description": "Test agent",
         "tools": mock_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [],
         "external_sub_agent_id_list": [],
         "model_names": ["GPT-4"],
@@ -2150,6 +2161,7 @@ def mock_get_model(model_id):
         "business_description": "Test agent",
         "tools": mock_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [],
         "external_sub_agent_id_list": [],
         "model_names": ["GPT-4"],
@@ -2248,6 +2260,7 @@ def mock_get_model(model_id):
         "business_description": "Test agent",
         "tools": mock_tools,
         "sub_agent_id_list": mock_sub_agent_ids,
+        "sub_agent_relations": [],
         "skills": [],
         "external_sub_agent_id_list": [],
         "model_names": ["GPT-4"],
@@ -4061,6 +4074,7 @@ async def test_import_agent_impl_imports_all_agents_and_links_relations(
         child_agent_id=101,
         tenant_id="test_tenant",
         user_id="test_user",
+        selected_agent_version_no=1,
     )
 
 
@@ -7550,8 +7564,8 @@ async def fake_import_agent_by_agent_id(import_agent_info, tenant_id, user_id, s
 
     relationships = []
 
-    def fake_insert_related_agent(parent_agent_id, child_agent_id, tenant_id, user_id):
-        relationships.append((parent_agent_id, child_agent_id, tenant_id, user_id))
+    def fake_insert_related_agent(parent_agent_id, child_agent_id, tenant_id, user_id, selected_agent_version_no=None):
+        relationships.append((parent_agent_id, child_agent_id, tenant_id, user_id, selected_agent_version_no))
 
     async def fake_update_tool_list(tenant_id, user_id):
         return None
@@ -7578,7 +7592,7 @@ async def fake_update_tool_list(tenant_id, user_id):
     # Child (2) must be imported before parent (1)
     assert imported_ids == [2, 1]
     # Relationship should be created between new IDs 101 (child) and 100 (parent)
-    assert relationships == [(100 + 1, 100 + 2, "tenant1", "user1")]
+    assert relationships == [(100 + 1, 100 + 2, "tenant1", "user1", 1)]
 
 
 # =====================================================================
@@ -16590,6 +16604,309 @@ async def test_get_agent_info_impl_all_models_deleted(
     assert result["model_name"] is None
 
 
+@patch('backend.services.agent_service.batch_search_agent_display_names')
+@patch('backend.services.agent_service.batch_search_version_names')
+@patch('backend.services.agent_service.batch_query_current_version_nos')
+@patch('backend.services.agent_service.query_sub_agent_relations')
+@patch('backend.services.agent_service.SkillService')
+@patch('backend.services.agent_service.query_external_sub_agents')
+@patch('backend.services.agent_service.check_agent_availability')
+@patch('backend.services.agent_service.get_model_by_model_id')
+@patch('backend.services.agent_service.query_sub_agents_id_list')
+@patch('backend.services.agent_service.search_tools_for_sub_agent')
+@patch('backend.services.agent_service.search_agent_info_by_agent_id')
+@pytest.mark.asyncio
+async def test_get_agent_info_impl_sub_agent_relations_with_pinned_version(
+    mock_search_agent_info, mock_search_tools, mock_query_sub_agents_id,
+    mock_get_model_by_model_id, mock_check_availability,
+    mock_query_external_sub_agents, mock_skill_service,
+    mock_query_sub_agent_relations, mock_batch_query_current_version_nos,
+    mock_batch_search_version_names, mock_batch_search_agent_display_names
+):
+    """Test get_agent_info_impl enriches sub_agent_relations with pinned version_no."""
+    mock_agent_info = {"agent_id": 123, "model_id": None, "business_description": "Test"}
+    mock_search_agent_info.return_value = mock_agent_info
+    mock_search_tools.return_value = []
+    mock_query_sub_agents_id.return_value = [456]
+    mock_get_model_by_model_id.return_value = None
+    mock_check_availability.return_value = (True, [])
+    mock_query_external_sub_agents.return_value = []
+
+    mock_skill_service_instance = MagicMock()
+    mock_skill_service_instance.list_skill_instances.return_value = []
+    mock_skill_service.return_value = mock_skill_service_instance
+
+    mock_query_sub_agent_relations.return_value = [
+        {"selected_agent_id": 456, "selected_agent_version_no": 2}
+    ]
+    mock_batch_query_current_version_nos.return_value = {}
+    mock_batch_search_version_names.return_value = [
+        {"agent_id": 456, "version_no": 2, "version_name": "v2.0"}
+    ]
+    mock_batch_search_agent_display_names.return_value = {456: "Sub Agent"}
+
+    result = await get_agent_info_impl(agent_id=123, tenant_id="test_tenant")
+
+    assert len(result["sub_agent_relations"]) == 1
+    rel = result["sub_agent_relations"][0]
+    assert rel["agent_id"] == 456
+    assert rel["agent_name"] == "Sub Agent"
+    assert rel["version_no"] == 2
+    assert rel["version_name"] == "v2.0"
+
+
+@patch('backend.services.agent_service.batch_search_agent_display_names')
+@patch('backend.services.agent_service.batch_search_version_names')
+@patch('backend.services.agent_service.batch_query_current_version_nos')
+@patch('backend.services.agent_service.query_sub_agent_relations')
+@patch('backend.services.agent_service.SkillService')
+@patch('backend.services.agent_service.query_external_sub_agents')
+@patch('backend.services.agent_service.check_agent_availability')
+@patch('backend.services.agent_service.get_model_by_model_id')
+@patch('backend.services.agent_service.query_sub_agents_id_list')
+@patch('backend.services.agent_service.search_tools_for_sub_agent')
+@patch('backend.services.agent_service.search_agent_info_by_agent_id')
+@pytest.mark.asyncio
+async def test_get_agent_info_impl_sub_agent_relations_null_version_fallback(
+    mock_search_agent_info, mock_search_tools, mock_query_sub_agents_id,
+    mock_get_model_by_model_id, mock_check_availability,
+    mock_query_external_sub_agents, mock_skill_service,
+    mock_query_sub_agent_relations, mock_batch_query_current_version_nos,
+    mock_batch_search_version_names, mock_batch_search_agent_display_names
+):
+    """Test get_agent_info_impl resolves null version_no via batch_query_current_version_nos."""
+    mock_agent_info = {"agent_id": 123, "model_id": None, "business_description": "Test"}
+    mock_search_agent_info.return_value = mock_agent_info
+    mock_search_tools.return_value = []
+    mock_query_sub_agents_id.return_value = [456]
+    mock_get_model_by_model_id.return_value = None
+    mock_check_availability.return_value = (True, [])
+    mock_query_external_sub_agents.return_value = []
+
+    mock_skill_service_instance = MagicMock()
+    mock_skill_service_instance.list_skill_instances.return_value = []
+    mock_skill_service.return_value = mock_skill_service_instance
+
+    mock_query_sub_agent_relations.return_value = [
+        {"selected_agent_id": 456, "selected_agent_version_no": None}
+    ]
+    mock_batch_query_current_version_nos.return_value = {456: 3}
+    mock_batch_search_version_names.return_value = [
+        {"agent_id": 456, "version_no": 3, "version_name": "v3.0"}
+    ]
+    mock_batch_search_agent_display_names.return_value = {456: "Sub Agent"}
+
+    result = await get_agent_info_impl(agent_id=123, tenant_id="test_tenant")
+
+    assert len(result["sub_agent_relations"]) == 1
+    rel = result["sub_agent_relations"][0]
+    assert rel["agent_id"] == 456
+    assert rel["version_no"] == 3
+    assert rel["version_name"] == "v3.0"
+
+
+@patch('backend.services.agent_service.batch_search_agent_display_names')
+@patch('backend.services.agent_service.batch_search_version_names')
+@patch('backend.services.agent_service.batch_query_current_version_nos')
+@patch('backend.services.agent_service.query_sub_agent_relations')
+@patch('backend.services.agent_service.SkillService')
+@patch('backend.services.agent_service.query_external_sub_agents')
+@patch('backend.services.agent_service.check_agent_availability')
+@patch('backend.services.agent_service.get_model_by_model_id')
+@patch('backend.services.agent_service.query_sub_agents_id_list')
+@patch('backend.services.agent_service.search_tools_for_sub_agent')
+@patch('backend.services.agent_service.search_agent_info_by_agent_id')
+@pytest.mark.asyncio
+async def test_get_agent_info_impl_sub_agent_relations_zero_version_fallback(
+    mock_search_agent_info, mock_search_tools, mock_query_sub_agents_id,
+    mock_get_model_by_model_id, mock_check_availability,
+    mock_query_external_sub_agents, mock_skill_service,
+    mock_query_sub_agent_relations, mock_batch_query_current_version_nos,
+    mock_batch_search_version_names, mock_batch_search_agent_display_names
+):
+    """Test get_agent_info_impl resolves version_no=0 via batch_query_current_version_nos."""
+    mock_agent_info = {"agent_id": 123, "model_id": None, "business_description": "Test"}
+    mock_search_agent_info.return_value = mock_agent_info
+    mock_search_tools.return_value = []
+    mock_query_sub_agents_id.return_value = [456]
+    mock_get_model_by_model_id.return_value = None
+    mock_check_availability.return_value = (True, [])
+    mock_query_external_sub_agents.return_value = []
+
+    mock_skill_service_instance = MagicMock()
+    mock_skill_service_instance.list_skill_instances.return_value = []
+    mock_skill_service.return_value = mock_skill_service_instance
+
+    mock_query_sub_agent_relations.return_value = [
+        {"selected_agent_id": 456, "selected_agent_version_no": 0}
+    ]
+    mock_batch_query_current_version_nos.return_value = {456: 1}
+    mock_batch_search_version_names.return_value = [
+        {"agent_id": 456, "version_no": 1, "version_name": "v1.0"}
+    ]
+    mock_batch_search_agent_display_names.return_value = {456: "Sub Agent"}
+
+    result = await get_agent_info_impl(agent_id=123, tenant_id="test_tenant")
+
+    assert len(result["sub_agent_relations"]) == 1
+    rel = result["sub_agent_relations"][0]
+    assert rel["version_no"] == 1
+    assert rel["version_name"] == "v1.0"
+
+
+@patch('backend.services.agent_service.batch_search_agent_display_names')
+@patch('backend.services.agent_service.batch_search_version_names')
+@patch('backend.services.agent_service.batch_query_current_version_nos')
+@patch('backend.services.agent_service.query_sub_agent_relations')
+@patch('backend.services.agent_service.SkillService')
+@patch('backend.services.agent_service.query_external_sub_agents')
+@patch('backend.services.agent_service.check_agent_availability')
+@patch('backend.services.agent_service.get_model_by_model_id')
+@patch('backend.services.agent_service.query_sub_agents_id_list')
+@patch('backend.services.agent_service.search_tools_for_sub_agent')
+@patch('backend.services.agent_service.search_agent_info_by_agent_id')
+@pytest.mark.asyncio
+async def test_get_agent_info_impl_sub_agent_relations_no_resolved_version(
+    mock_search_agent_info, mock_search_tools, mock_query_sub_agents_id,
+    mock_get_model_by_model_id, mock_check_availability,
+    mock_query_external_sub_agents, mock_skill_service,
+    mock_query_sub_agent_relations, mock_batch_query_current_version_nos,
+    mock_batch_search_version_names, mock_batch_search_agent_display_names
+):
+    """Test get_agent_info_impl handles when no published version exists for sub-agent."""
+    mock_agent_info = {"agent_id": 123, "model_id": None, "business_description": "Test"}
+    mock_search_agent_info.return_value = mock_agent_info
+    mock_search_tools.return_value = []
+    mock_query_sub_agents_id.return_value = [456]
+    mock_get_model_by_model_id.return_value = None
+    mock_check_availability.return_value = (True, [])
+    mock_query_external_sub_agents.return_value = []
+
+    mock_skill_service_instance = MagicMock()
+    mock_skill_service_instance.list_skill_instances.return_value = []
+    mock_skill_service.return_value = mock_skill_service_instance
+
+    mock_query_sub_agent_relations.return_value = [
+        {"selected_agent_id": 456, "selected_agent_version_no": None}
+    ]
+    mock_batch_query_current_version_nos.return_value = {}
+    mock_batch_search_version_names.return_value = []
+    mock_batch_search_agent_display_names.return_value = {456: "Sub Agent"}
+
+    result = await get_agent_info_impl(agent_id=123, tenant_id="test_tenant")
+
+    assert len(result["sub_agent_relations"]) == 1
+    rel = result["sub_agent_relations"][0]
+    assert rel["agent_id"] == 456
+    assert rel["version_no"] is None
+    assert rel["version_name"] is None
+    assert rel["agent_name"] == "Sub Agent"
+
+
+@patch('backend.services.agent_service.batch_search_agent_display_names')
+@patch('backend.services.agent_service.batch_search_version_names')
+@patch('backend.services.agent_service.batch_query_current_version_nos')
+@patch('backend.services.agent_service.query_sub_agent_relations')
+@patch('backend.services.agent_service.SkillService')
+@patch('backend.services.agent_service.query_external_sub_agents')
+@patch('backend.services.agent_service.check_agent_availability')
+@patch('backend.services.agent_service.get_model_by_model_id')
+@patch('backend.services.agent_service.query_sub_agents_id_list')
+@patch('backend.services.agent_service.search_tools_for_sub_agent')
+@patch('backend.services.agent_service.search_agent_info_by_agent_id')
+@pytest.mark.asyncio
+async def test_get_agent_info_impl_sub_agent_relations_with_none_agent_id(
+    mock_search_agent_info, mock_search_tools, mock_query_sub_agents_id,
+    mock_get_model_by_model_id, mock_check_availability,
+    mock_query_external_sub_agents, mock_skill_service,
+    mock_query_sub_agent_relations, mock_batch_query_current_version_nos,
+    mock_batch_search_version_names, mock_batch_search_agent_display_names
+):
+    """Test get_agent_info_impl handles relations with selected_agent_id=None gracefully."""
+    mock_agent_info = {"agent_id": 123, "model_id": None, "business_description": "Test"}
+    mock_search_agent_info.return_value = mock_agent_info
+    mock_search_tools.return_value = []
+    mock_query_sub_agents_id.return_value = [456, None]
+    mock_get_model_by_model_id.return_value = None
+    mock_check_availability.return_value = (True, [])
+    mock_query_external_sub_agents.return_value = []
+
+    mock_skill_service_instance = MagicMock()
+    mock_skill_service_instance.list_skill_instances.return_value = []
+    mock_skill_service.return_value = mock_skill_service_instance
+
+    # Include a relation with selected_agent_id=None alongside a normal one
+    mock_query_sub_agent_relations.return_value = [
+        {"selected_agent_id": 456, "selected_agent_version_no": 2},
+        {"selected_agent_id": None, "selected_agent_version_no": 5},
+    ]
+    mock_batch_query_current_version_nos.return_value = {}
+    mock_batch_search_version_names.return_value = [
+        {"agent_id": 456, "version_no": 2, "version_name": "v2.0"}
+    ]
+    mock_batch_search_agent_display_names.return_value = {456: "Sub Agent"}
+
+    result = await get_agent_info_impl(agent_id=123, tenant_id="test_tenant")
+
+    assert len(result["sub_agent_relations"]) == 2
+    # First relation (normal) should be enriched correctly
+    rel_normal = result["sub_agent_relations"][0]
+    assert rel_normal["agent_id"] == 456
+    assert rel_normal["agent_name"] == "Sub Agent"
+    assert rel_normal["version_no"] == 2
+    assert rel_normal["version_name"] == "v2.0"
+    # Second relation (None agent_id) should have None values without crashing
+    rel_none = result["sub_agent_relations"][1]
+    assert rel_none["agent_id"] is None
+    assert rel_none["agent_name"] is None
+    assert rel_none["version_no"] == 5
+    assert rel_none["version_name"] is None
+
+
+@patch('backend.services.agent_service.update_related_agents')
+@patch('backend.services.agent_service.query_sub_agents_id_list')
+@patch('backend.services.agent_service.update_agent')
+@patch('backend.services.agent_service.get_current_user_info')
+@pytest.mark.asyncio
+async def test_update_agent_info_impl_with_related_agents_objects(
+    mock_get_current_user_info,
+    mock_update_agent,
+    mock_query_sub_agents_id_list,
+    mock_update_related_agents
+):
+    """Test update_agent_info_impl passes related_agents dicts when RelatedAgentInfo objects are provided."""
+    mock_get_current_user_info.return_value = ("test_user", "test_tenant", "en")
+    mock_query_sub_agents_id_list.return_value = []
+
+    request = MagicMock()
+    request.agent_id = 123
+    request.enabled_tool_ids = None
+    request.related_agent_ids = [456, 789]
+
+    mock_ra1 = MagicMock()
+    mock_ra1.agent_id = 456
+    mock_ra1.version_no = 2
+    mock_ra2 = MagicMock()
+    mock_ra2.agent_id = 789
+    mock_ra2.version_no = None
+    request.related_agents = [mock_ra1, mock_ra2]
+
+    apply_default_prompt_template_request_fields(request)
+
+    result = await update_agent_info_impl(request, authorization="Bearer token")
+
+    assert result["agent_id"] == 123
+    mock_update_related_agents.assert_called_once_with(
+        parent_agent_id=123,
+        tenant_id="test_tenant",
+        user_id="test_user",
+        related_agents=[
+            {"agent_id": 456, "version_no": 2},
+            {"agent_id": 789, "version_no": None},
+        ],
+    )
+
+
 @patch("backend.services.agent_service.get_user_language", return_value="en-US")
 @patch("backend.services.agent_service.get_current_user_info", return_value=("user-1", "tenant-1", "zh-CN"))
 def test_resolve_user_tenant_language_honors_explicit_identity(
diff --git a/test/backend/services/test_agent_version_service.py b/test/backend/services/test_agent_version_service.py
index f7b59eb9f..51c3452b5 100644
--- a/test/backend/services/test_agent_version_service.py
+++ b/test/backend/services/test_agent_version_service.py
@@ -178,6 +178,7 @@ class ValidationError(Exception):
     _check_version_snapshot_availability,
     _get_version_detail_or_draft,
     _remove_audit_fields_for_insert,
+    _build_sub_agent_relations,
 )
 
 
@@ -3374,3 +3375,335 @@ def test_list_published_agents_impl_empty_model_ids(monkeypatch):
     agent_version_service_module.get_valid_model_ids.assert_called_once_with([], "tenant1")
     assert result[0]["model_ids"] == []
     assert result[0]["model_names"] == []
+
+
+# ===================== _build_sub_agent_relations tests =====================
+
+
+def test_build_sub_agent_relations_empty():
+    """Test _build_sub_agent_relations with empty list returns empty list."""
+    assert _build_sub_agent_relations([]) == []
+
+
+def test_build_sub_agent_relations_with_version():
+    """Test _build_sub_agent_relations maps selected_agent_id and selected_agent_version_no."""
+    relations = [
+        {"selected_agent_id": 2, "selected_agent_version_no": 3},
+        {"selected_agent_id": 5, "selected_agent_version_no": 1},
+    ]
+    result = _build_sub_agent_relations(relations)
+    assert result == [
+        {"agent_id": 2, "version_no": 3},
+        {"agent_id": 5, "version_no": 1},
+    ]
+
+
+def test_build_sub_agent_relations_null_version():
+    """Test _build_sub_agent_relations handles missing selected_agent_version_no as None."""
+    relations = [
+        {"selected_agent_id": 2},
+        {"selected_agent_id": 5, "selected_agent_version_no": None},
+    ]
+    result = _build_sub_agent_relations(relations)
+    assert result == [
+        {"agent_id": 2, "version_no": None},
+        {"agent_id": 5, "version_no": None},
+    ]
+
+
+# ===================== get_version_detail_impl sub_agent_relations tests =====================
+
+
+def test_get_version_detail_impl_with_sub_agent_relations(monkeypatch):
+    """Test get_version_detail_impl populates sub_agent_relations from snapshots."""
+    mock_version = {
+        "version_no": 1,
+        "version_name": "v1.0",
+        "status": "RELEASED",
+        "release_note": "",
+        "source_type": "NORMAL",
+        "source_version_no": None,
+    }
+
+    mock_agent_snapshot = {
+        "agent_id": 1,
+        "name": "Test Agent",
+        "model_ids": [],
+        "group_ids": None,
+    }
+
+    mock_relations_snapshot = [
+        {"selected_agent_id": 2, "selected_agent_version_no": 3},
+        {"selected_agent_id": 5, "selected_agent_version_no": 1},
+    ]
+
+    monkeypatch.setattr(agent_version_service_module, "search_version_by_version_no", MagicMock(return_value=mock_version))
+    monkeypatch.setattr(agent_version_service_module, "query_agent_snapshot", MagicMock(
+        return_value=(mock_agent_snapshot, [], mock_relations_snapshot)
+    ))
+    monkeypatch.setattr(agent_version_service_module, "get_model_by_model_id", MagicMock(return_value=None))
+    monkeypatch.setattr(skill_db_mock, "query_skill_instances_by_agent_id", MagicMock(return_value=[]))
+
+    result = get_version_detail_impl(agent_id=1, tenant_id="tenant1", version_no=1)
+
+    assert result["sub_agent_id_list"] == [2, 5]
+    assert result["sub_agent_relations"] == [
+        {"agent_id": 2, "version_no": 3},
+        {"agent_id": 5, "version_no": 1},
+    ]
+
+
+# ===================== list_published_agents_impl sub_agent_relations tests =====================
+
+
+def test_list_published_agents_impl_with_sub_agent_relations(monkeypatch):
+    """Test list_published_agents_impl populates sub_agent_relations from snapshots."""
+    agent_db_mock.query_all_agent_info_by_tenant_id = MagicMock(
+        return_value=[
+            {
+                "agent_id": 1,
+                "enabled": True,
+                "current_version_no": 1,
+                "group_ids": "1,2",
+                "created_by": "user1",
+                "name": "Test Agent",
+                "display_name": "Test Agent",
+                "description": "Test",
+                "author": "Author",
+                "is_new": False,
+            }
+        ]
+    )
+
+    agent_service_mock.get_user_tenant_by_user_id = MagicMock(
+        return_value={"user_role": "ADMIN"}
+    )
+
+    mock_relations = [
+        {"selected_agent_id": 3, "selected_agent_version_no": 2},
+    ]
+
+    agent_version_db_mock.query_agent_snapshot = MagicMock(
+        return_value=(
+            {
+                "agent_id": 1,
+                "name": "Test Agent",
+                "model_ids": [1],
+                "description": "Test",
+                "is_main_agent": True,
+            },
+            [],
+            mock_relations,
+        )
+    )
+
+    agent_version_db_mock.query_version_list = MagicMock(
+        return_value=[{"version_no": 1, "version_name": "v1.0"}]
+    )
+
+    agent_service_mock.check_agent_availability = MagicMock(
+        return_value=(True, [])
+    )
+    agent_service_mock._apply_duplicate_name_availability_rules = MagicMock()
+    agent_service_mock.get_model_by_model_id = MagicMock(
+        return_value={"display_name": "Test Model", "model_name": "test_model"}
+    )
+
+    # Spy on _build_sub_agent_relations to verify it's called with the right relations
+    original_build = agent_version_service_module._build_sub_agent_relations
+    captured_relations = []
+    def spy_build(relations):
+        captured_relations.append(relations)
+        return original_build(relations)
+    monkeypatch.setattr(agent_version_service_module, "_build_sub_agent_relations", spy_build)
+
+    result = asyncio.run(list_published_agents_impl(tenant_id="tenant1", user_id="user1"))
+
+    assert len(result) == 1
+    # Verify _build_sub_agent_relations was called with the snapshot relations
+    assert len(captured_relations) == 1
+    assert captured_relations[0] == mock_relations
+    # Verify the mapped result is correct
+    assert original_build(mock_relations) == [
+        {"agent_id": 3, "version_no": 2},
+    ]
+
+
+# ===================== compare_versions_impl with falsy model_ids tests =====================
+
+
+def test_compare_versions_impl_model_ids_none(monkeypatch):
+    """Test comparing versions where model_ids is None (triggers _normalize_model_ids return [])."""
+    version_a = {
+        "name": "Agent A",
+        "model_ids": None,
+        "model_names": [],
+        "model_name": None,
+        "max_steps": 10,
+        "description": "Desc A",
+        "duty_prompt": "Prompt A",
+        "tools": [],
+        "sub_agent_id_list": [],
+        "skills": [],
+    }
+    version_b = {
+        "name": "Agent A",
+        "model_ids": [1, 2],
+        "model_names": ["Model A1", "Model A2"],
+        "model_name": "Model A1",
+        "max_steps": 10,
+        "description": "Desc A",
+        "duty_prompt": "Prompt A",
+        "tools": [],
+        "sub_agent_id_list": [],
+        "skills": [],
+    }
+
+    with patch('backend.services.agent_version_service._get_version_detail_or_draft') as mock_get_detail:
+        mock_get_detail.side_effect = [version_a, version_b]
+
+        result = compare_versions_impl(
+            agent_id=1,
+            tenant_id="tenant1",
+            version_no_a=0,
+            version_no_b=1,
+        )
+
+        difference_fields = [d["field"] for d in result["differences"]]
+        assert "model_ids" in difference_fields
+
+
+def test_compare_versions_impl_both_model_ids_empty(monkeypatch):
+    """Test comparing versions where both model_ids are empty (no difference)."""
+    version_a = {
+        "name": "Agent A",
+        "model_ids": [],
+        "model_names": [],
+        "model_name": None,
+        "max_steps": 10,
+        "description": "Desc A",
+        "duty_prompt": "Prompt A",
+        "tools": [],
+        "sub_agent_id_list": [],
+        "skills": [],
+    }
+    version_b = {
+        "name": "Agent A",
+        "model_ids": None,
+        "model_names": [],
+        "model_name": None,
+        "max_steps": 10,
+        "description": "Desc A",
+        "duty_prompt": "Prompt A",
+        "tools": [],
+        "sub_agent_id_list": [],
+        "skills": [],
+    }
+
+    with patch('backend.services.agent_version_service._get_version_detail_or_draft') as mock_get_detail:
+        mock_get_detail.side_effect = [version_a, version_b]
+
+        result = compare_versions_impl(
+            agent_id=1,
+            tenant_id="tenant1",
+            version_no_a=0,
+            version_no_b=1,
+        )
+
+        difference_fields = [d["field"] for d in result["differences"]]
+        assert "model_ids" not in difference_fields
+
+
+# ===================== list_published_agents_impl edge case tests =====================
+
+
+def test_list_published_agents_impl_no_available_versions(monkeypatch):
+    """Test list_published_agents_impl skips agent when no available versions found."""
+    agent_db_mock.query_all_agent_info_by_tenant_id = MagicMock(
+        return_value=[
+            {
+                "agent_id": 1,
+                "enabled": True,
+                "current_version_no": 1,
+                "group_ids": "1,2",
+                "created_by": "user1",
+                "name": "Test Agent",
+                "display_name": "Test Agent",
+                "description": "Test",
+                "author": "Author",
+                "is_new": False,
+            }
+        ]
+    )
+
+    agent_service_mock.get_user_tenant_by_user_id = MagicMock(
+        return_value={"user_role": "ADMIN"}
+    )
+
+    # Return empty list - no available versions
+    agent_version_db_mock.query_version_list = MagicMock(return_value=[])
+
+    result = asyncio.run(list_published_agents_impl(tenant_id="tenant1", user_id="user1"))
+
+    # Agent should be skipped because no available versions
+    assert len(result) == 0
+
+
+def test_list_published_agents_impl_model_not_found(monkeypatch):
+    """Test list_published_agents_impl handles model not found (get_model_by_model_id returns None)."""
+    agent_db_mock.query_all_agent_info_by_tenant_id = MagicMock(
+        return_value=[
+            {
+                "agent_id": 1,
+                "enabled": True,
+                "current_version_no": 1,
+                "group_ids": "1,2",
+                "created_by": "user1",
+                "name": "Test Agent",
+                "display_name": "Test Agent",
+                "description": "Test",
+                "author": "Author",
+                "is_new": False,
+            }
+        ]
+    )
+
+    agent_service_mock.get_user_tenant_by_user_id = MagicMock(
+        return_value={"user_role": "ADMIN"}
+    )
+
+    agent_version_db_mock.query_agent_snapshot = MagicMock(
+        return_value=(
+            {
+                "agent_id": 1,
+                "name": "Test Agent",
+                "model_ids": [99],
+                "description": "Test",
+                "is_main_agent": True,
+            },
+            [],
+            [],
+        )
+    )
+
+    agent_version_db_mock.query_version_list = MagicMock(
+        return_value=[{"version_no": 1, "version_name": "v1.0"}]
+    )
+
+    agent_service_mock.check_agent_availability = MagicMock(
+        return_value=(True, [])
+    )
+    agent_service_mock._apply_duplicate_name_availability_rules = MagicMock()
+    # Model not found - returns None
+    agent_service_mock.get_model_by_model_id = MagicMock(return_value=None)
+    # Reset get_valid_model_ids to pass through (previous tests may have overridden it)
+    agent_version_service_module.get_valid_model_ids = MagicMock(
+        side_effect=lambda model_ids, tenant_id: model_ids
+    )
+
+    result = asyncio.run(list_published_agents_impl(tenant_id="tenant1", user_id="user1"))
+
+    assert len(result) == 1
+    # When model is not found, model_names should contain str(mid) as fallback
+    assert result[0]["model_names"] == ["99"]
+    assert result[0]["model_name"] == "99"