diff --git a/crates/frontend/src/api.rs b/crates/frontend/src/api.rs
index 685d15c..f30e1b5 100644
--- a/crates/frontend/src/api.rs
+++ b/crates/frontend/src/api.rs
@@ -6132,6 +6132,8 @@ pub struct AdminLlmGatewayKeyView {
     #[serde(default = "default_anthropic_upstream_pool_mode")]
     pub kiro_anthropic_upstream_pool_mode: String,
     pub model_name_map: Option<BTreeMap<String, String>>,
+    #[serde(default)]
+    pub kiro_model_group_preferences: BTreeMap<String, String>,
     pub request_max_concurrency: Option<u64>,
     pub request_min_start_interval_ms: Option<u64>,
     #[serde(default = "default_true")]
@@ -9030,6 +9032,7 @@ pub async fn create_admin_llm_gateway_key(
             preferred_pool_strategy: default_kiro_pool_strategy(),
             kiro_anthropic_upstream_pool_mode: default_anthropic_upstream_pool_mode(),
             model_name_map: None,
+            kiro_model_group_preferences: BTreeMap::new(),
             request_max_concurrency,
             request_min_start_interval_ms,
             kiro_request_validation_enabled: true,
@@ -9096,6 +9099,7 @@ pub struct PatchAdminLlmGatewayKeyRequest<'a> {
     pub preferred_pool_strategy: Option<&'a str>,
     pub kiro_anthropic_upstream_pool_mode: Option<&'a str>,
     pub model_name_map: Option<&'a BTreeMap<String, String>>,
+    pub kiro_model_group_preferences: Option<&'a BTreeMap<String, String>>,
     pub request_max_concurrency: Option<u64>,
     pub request_min_start_interval_ms: Option<u64>,
     pub codex_fast_enabled: Option<bool>,
@@ -9136,6 +9140,7 @@ pub async fn patch_admin_llm_gateway_key(
             request.preferred_pool_strategy,
             request.kiro_anthropic_upstream_pool_mode,
             request.model_name_map,
+            request.kiro_model_group_preferences,
             request.request_max_concurrency,
             request.request_min_start_interval_ms,
             request.codex_fast_enabled,
@@ -9236,6 +9241,11 @@ pub async fn patch_admin_llm_gateway_key(
                 .map_err(|e| format!("Serialize error: {:?}", e))?;
             body.insert("model_name_map".to_string(), value);
         }
+        if let Some(preferences) = request.kiro_model_group_preferences {
+            let value = serde_json::to_value(preferences)
+                .map_err(|e| format!("Serialize error: {:?}", e))?;
+            body.insert("kiro_model_group_preferences".to_string(), value);
+        }
         if let Some(request_max_concurrency) = request.request_max_concurrency {
             body.insert(
                 "request_max_concurrency".to_string(),
@@ -11445,6 +11455,7 @@ pub async fn create_admin_kiro_key(
             preferred_pool_strategy: default_kiro_pool_strategy(),
             kiro_anthropic_upstream_pool_mode: default_anthropic_upstream_pool_mode(),
             model_name_map: None,
+            kiro_model_group_preferences: BTreeMap::new(),
             request_max_concurrency: None,
             request_min_start_interval_ms: None,
             kiro_request_validation_enabled: true,
@@ -11513,6 +11524,7 @@ pub async fn patch_admin_kiro_key(
             request.preferred_pool_strategy,
             request.kiro_anthropic_upstream_pool_mode,
             request.model_name_map,
+            request.kiro_model_group_preferences,
             request.request_max_concurrency,
             request.request_min_start_interval_ms,
             request.kiro_request_validation_enabled,
@@ -11608,6 +11620,11 @@ pub async fn patch_admin_kiro_key(
                 .map_err(|e| format!("Serialize error: {:?}", e))?;
             body.insert("model_name_map".to_string(), value);
         }
+        if let Some(preferences) = request.kiro_model_group_preferences {
+            let value = serde_json::to_value(preferences)
+                .map_err(|e| format!("Serialize error: {:?}", e))?;
+            body.insert("kiro_model_group_preferences".to_string(), value);
+        }
         if let Some(kiro_request_validation_enabled) = request.kiro_request_validation_enabled {
             body.insert(
                 "kiro_request_validation_enabled".to_string(),
diff --git a/crates/frontend/src/pages/admin_kiro_gateway.rs b/crates/frontend/src/pages/admin_kiro_gateway.rs
index 1c369ac..82ce3d2 100644
--- a/crates/frontend/src/pages/admin_kiro_gateway.rs
+++ b/crates/frontend/src/pages/admin_kiro_gateway.rs
@@ -793,6 +793,26 @@ fn kiro_key_route_summary(
     }
 }
 
+fn kiro_model_group_preferences_summary(
+    preferences: &BTreeMap<String, String>,
+    account_groups: &[AdminAccountGroupOptionView],
+) -> String {
+    if preferences.is_empty() {
+        return "0 rules".to_string();
+    }
+    let mut entries = preferences
+        .iter()
+        .take(3)
+        .map(|(model, group_id)| {
+            format!("{model} -> {}", kiro_group_name_for_id(account_groups, group_id))
+        })
+        .collect::<Vec<_>>();
+    if preferences.len() > entries.len() {
+        entries.push(format!("+{}", preferences.len() - entries.len()));
+    }
+    format!("{} rules · {}", preferences.len(), entries.join(" · "))
+}
+
 fn kiro_pool_strategy_label(strategy: &str) -> &'static str {
     match llm_store::normalize_kiro_pool_strategy(strategy) {
         Some(llm_store::KIRO_POOL_STRATEGY_BALANCED) => "亲和 + 动态",
@@ -1795,6 +1815,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
     let anthropic_upstream_pool_mode =
         use_state(|| props.key_item.kiro_anthropic_upstream_pool_mode.clone());
     let model_name_map = use_state(|| props.key_item.model_name_map.clone().unwrap_or_default());
+    let model_group_preferences = use_state(|| props.key_item.kiro_model_group_preferences.clone());
     let kiro_request_validation_enabled =
         use_state(|| props.key_item.kiro_request_validation_enabled);
     let kiro_cache_estimation_enabled = use_state(|| props.key_item.kiro_cache_estimation_enabled);
@@ -1820,6 +1841,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
     let billable_multiplier_settings_expanded = use_state(|| false);
     let route_settings_expanded = use_state(|| false);
     let model_mapping_expanded = use_state(|| false);
+    let model_group_routing_open = use_state(|| false);
     let saving = use_state(|| false);
     let feedback = use_state(|| None::<String>);
 
@@ -1835,6 +1857,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
         let preferred_pool_strategy = preferred_pool_strategy.clone();
         let anthropic_upstream_pool_mode = anthropic_upstream_pool_mode.clone();
         let model_name_map = model_name_map.clone();
+        let model_group_preferences = model_group_preferences.clone();
         let kiro_request_validation_enabled = kiro_request_validation_enabled.clone();
         let kiro_cache_estimation_enabled = kiro_cache_estimation_enabled.clone();
         let kiro_zero_cache_debug_enabled = kiro_zero_cache_debug_enabled.clone();
@@ -1852,6 +1875,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
         let key_billable_multiplier_effective_baseline =
             key_billable_multiplier_effective_baseline.clone();
         let billable_multiplier_settings_expanded = billable_multiplier_settings_expanded.clone();
+        let model_group_routing_open = model_group_routing_open.clone();
         let initial_effective_billable_multiplier_json_for_effect =
             initial_effective_billable_multiplier_json.clone();
         use_effect_with((props.key_item.clone(), props.account_groups.clone()), move |_| {
@@ -1872,6 +1896,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
             preferred_pool_strategy.set(key_item.preferred_pool_strategy.clone());
             anthropic_upstream_pool_mode.set(key_item.kiro_anthropic_upstream_pool_mode.clone());
             model_name_map.set(key_item.model_name_map.clone().unwrap_or_default());
+            model_group_preferences.set(key_item.kiro_model_group_preferences.clone());
             kiro_request_validation_enabled.set(key_item.kiro_request_validation_enabled);
             kiro_cache_estimation_enabled.set(key_item.kiro_cache_estimation_enabled);
             kiro_zero_cache_debug_enabled.set(key_item.kiro_zero_cache_debug_enabled);
@@ -1890,6 +1915,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
             key_billable_multiplier_effective_baseline
                 .set(initial_effective_billable_multiplier_json_for_effect.clone());
             billable_multiplier_settings_expanded.set(false);
+            model_group_routing_open.set(false);
             || ()
         });
     }
@@ -1914,6 +1940,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
         let preferred_pool_strategy = preferred_pool_strategy.clone();
         let anthropic_upstream_pool_mode = anthropic_upstream_pool_mode.clone();
         let model_name_map = model_name_map.clone();
+        let model_group_preferences = model_group_preferences.clone();
         let kiro_request_validation_enabled = kiro_request_validation_enabled.clone();
         let kiro_cache_estimation_enabled = kiro_cache_estimation_enabled.clone();
         let kiro_zero_cache_debug_enabled = kiro_zero_cache_debug_enabled.clone();
@@ -1948,6 +1975,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
             let preferred_pool_strategy_value = (*preferred_pool_strategy).clone();
             let anthropic_upstream_pool_mode_value = (*anthropic_upstream_pool_mode).clone();
             let model_name_map_value = (*model_name_map).clone();
+            let model_group_preferences_value = (*model_group_preferences).clone();
             let kiro_request_validation_enabled_value = *kiro_request_validation_enabled;
             let kiro_cache_estimation_enabled_value = *kiro_cache_estimation_enabled;
             let kiro_zero_cache_debug_enabled_value = *kiro_zero_cache_debug_enabled;
@@ -2028,6 +2056,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
                         anthropic_upstream_pool_mode_value.as_str(),
                     ),
                     model_name_map: Some(&model_name_map_value),
+                    kiro_model_group_preferences: Some(&model_group_preferences_value),
                     request_max_concurrency: None,
                     request_min_start_interval_ms: None,
                     codex_fast_enabled: None,
@@ -2089,6 +2118,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
         let preferred_pool_strategy = preferred_pool_strategy.clone();
         let anthropic_upstream_pool_mode = anthropic_upstream_pool_mode.clone();
         let model_name_map = model_name_map.clone();
+        let model_group_preferences = model_group_preferences.clone();
         let kiro_cache_estimation_enabled = kiro_cache_estimation_enabled.clone();
         let kiro_zero_cache_debug_enabled = kiro_zero_cache_debug_enabled.clone();
         let kiro_full_request_logging_enabled = kiro_full_request_logging_enabled.clone();
@@ -2108,6 +2138,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
             let preferred_pool_strategy_value = (*preferred_pool_strategy).clone();
             let anthropic_upstream_pool_mode_value = (*anthropic_upstream_pool_mode).clone();
             let model_name_map_value = (*model_name_map).clone();
+            let model_group_preferences_value = (*model_group_preferences).clone();
             let kiro_cache_estimation_enabled_value = *kiro_cache_estimation_enabled;
             let kiro_zero_cache_debug_enabled_value = *kiro_zero_cache_debug_enabled;
             let kiro_full_request_logging_enabled_value = *kiro_full_request_logging_enabled;
@@ -2143,6 +2174,7 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
                         anthropic_upstream_pool_mode_value.as_str(),
                     ),
                     model_name_map: Some(&model_name_map_value),
+                    kiro_model_group_preferences: Some(&model_group_preferences_value),
                     request_max_concurrency: None,
                     request_min_start_interval_ms: None,
                     codex_fast_enabled: None,
@@ -2231,6 +2263,58 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
         let model_name_map = model_name_map.clone();
         Callback::from(move |_| model_name_map.set(BTreeMap::new()))
     };
+    let on_reset_model_group_preferences = {
+        let model_group_preferences = model_group_preferences.clone();
+        Callback::from(move |_| model_group_preferences.set(BTreeMap::new()))
+    };
+    let on_save_model_group_preferences = {
+        let key_id = props.key_item.id.clone();
+        let key_name = props.key_item.name.clone();
+        let model_group_preferences = model_group_preferences.clone();
+        let model_group_routing_open = model_group_routing_open.clone();
+        let saving = saving.clone();
+        let feedback = feedback.clone();
+        let on_flash = props.on_flash.clone();
+        let on_reload = props.on_reload.clone();
+        Callback::from(move |_| {
+            if *saving {
+                return;
+            }
+            let key_id = key_id.clone();
+            let key_name = key_name.clone();
+            let preferences_value = (*model_group_preferences).clone();
+            let model_group_routing_open = model_group_routing_open.clone();
+            let saving = saving.clone();
+            let feedback = feedback.clone();
+            let on_flash = on_flash.clone();
+            let on_reload = on_reload.clone();
+            wasm_bindgen_futures::spawn_local(async move {
+                saving.set(true);
+                feedback.set(None);
+                match patch_admin_kiro_key(&key_id, PatchAdminLlmGatewayKeyRequest {
+                    kiro_model_group_preferences: Some(&preferences_value),
+                    ..PatchAdminLlmGatewayKeyRequest::default()
+                })
+                .await
+                {
+                    Ok(_) => {
+                        feedback.set(Some("Saved model routing.".to_string()));
+                        model_group_routing_open.set(false);
+                        on_flash.emit((format!("Saved model routing for `{key_name}`."), false));
+                        on_reload.emit(());
+                    },
+                    Err(err) => {
+                        feedback.set(Some(err.clone()));
+                        on_flash.emit((
+                            format!("Failed to save model routing for `{key_name}`.\n{err}"),
+                            true,
+                        ));
+                    },
+                }
+                saving.set(false);
+            });
+        })
+    };
     let on_restore_inherit = {
         let key_id = props.key_item.id.clone();
         let key_name = props.key_item.name.clone();
@@ -2373,6 +2457,10 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
             .collect::<Vec<_>>()
             .join(" · ")
     };
+    let model_group_routing_summary = kiro_model_group_preferences_summary(
+        &model_group_preferences,
+        props.account_groups.as_slice(),
+    );
     html! {
         <article class={classes!("rounded-xl", "border", "border-[var(--border)]", "bg-[var(--surface)]", "p-4")}>
             <div class={classes!("flex", "items-start", "justify-between", "gap-3", "flex-wrap")}>
@@ -2953,6 +3041,26 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
                         </div>
                     }
                 </div>
+                <div class={classes!("md:col-span-2", "rounded-lg", "border", "border-[var(--border)]", "bg-[var(--surface-alt)]", "px-3", "py-3")}>
+                    <div class={classes!("flex", "items-center", "justify-between", "gap-3", "flex-wrap")}>
+                        <div class={classes!("min-w-0")}>
+                            <div class={classes!("text-xs", "uppercase", "tracking-[0.16em]", "text-[var(--muted)]")}>{ "Model Group Routing" }</div>
+                            <div class={classes!("mt-1", "text-xs", "text-[var(--muted)]", "break-words")}>
+                                { model_group_routing_summary.clone() }
+                            </div>
+                        </div>
+                        <button
+                            type="button"
+                            class={classes!("btn-terminal", "text-xs")}
+                            onclick={{
+                                let model_group_routing_open = model_group_routing_open.clone();
+                                Callback::from(move |_| model_group_routing_open.set(true))
+                            }}
+                        >
+                            { "Configure" }
+                        </button>
+                    </div>
+                </div>
                 <div class={classes!("md:col-span-2", "rounded-lg", "border", "border-[var(--border)]", "bg-[var(--surface-alt)]", "px-3", "py-3")}>
                     <div class={classes!("flex", "items-center", "justify-between", "gap-3", "flex-wrap")}>
                         <div>
@@ -3034,6 +3142,126 @@ fn kiro_key_editor_card(props: &KiroKeyEditorCardProps) -> Html {
                 </div>
             </div>
 
+            if *model_group_routing_open {
+                <div class={classes!("fixed", "inset-0", "z-50")}>
+                    <button
+                        type="button"
+                        class={classes!("absolute", "inset-0", "h-full", "w-full", "border-0", "bg-black/45", "p-0")}
+                        aria-label="Close model group routing"
+                        onclick={{
+                            let model_group_routing_open = model_group_routing_open.clone();
+                            Callback::from(move |_| model_group_routing_open.set(false))
+                        }}
+                    />
+                    <section class={classes!("absolute", "right-0", "top-0", "flex", "h-full", "w-full", "max-w-3xl", "flex-col", "border-l", "border-[var(--border)]", "bg-[var(--surface)]", "shadow-2xl")}>
+                        <div class={classes!("flex", "items-start", "justify-between", "gap-3", "border-b", "border-[var(--border)]", "px-5", "py-4")}>
+                            <div class={classes!("min-w-0")}>
+                                <div class={classes!("text-xs", "uppercase", "tracking-[0.16em]", "text-[var(--muted)]")}>{ "Model Group Routing" }</div>
+                                <h4 class={classes!("m-0", "mt-1", "text-base", "font-semibold", "text-[var(--text)]")}>
+                                    { props.key_item.name.clone() }
+                                </h4>
+                                <div class={classes!("mt-1", "text-xs", "text-[var(--muted)]", "break-words")}>
+                                    { model_group_routing_summary.clone() }
+                                </div>
+                            </div>
+                            <button
+                                type="button"
+                                class={classes!("btn-terminal", "text-xs")}
+                                onclick={{
+                                    let model_group_routing_open = model_group_routing_open.clone();
+                                    Callback::from(move |_| model_group_routing_open.set(false))
+                                }}
+                            >
+                                { "Close" }
+                            </button>
+                        </div>
+                        <div class={classes!("min-h-0", "flex-1", "overflow-y-auto", "px-5", "py-4")}>
+                            if props.available_models.is_empty() {
+                                <div class={classes!("rounded-lg", "border", "border-[var(--border)]", "bg-[var(--surface-alt)]", "px-4", "py-4", "text-sm", "text-[var(--muted)]")}>
+                                    { "No model inventory loaded." }
+                                </div>
+                            } else {
+                                <div class={classes!("grid", "gap-2")}>
+                                    { for props.available_models.iter().map(|model| {
+                                        let model_id = model.id.clone();
+                                        let selected_group_id = (*model_group_preferences)
+                                            .get(&model_id)
+                                            .cloned()
+                                            .unwrap_or_default();
+                                        let model_group_preferences = model_group_preferences.clone();
+                                        let account_groups = props.account_groups.clone();
+                                        html! {
+                                            <div class={classes!("grid", "gap-3", "rounded-lg", "border", "border-[var(--border)]", "bg-[var(--surface-alt)]", "px-3", "py-3", "lg:grid-cols-[minmax(0,1fr)_minmax(16rem,22rem)]")}>
+                                                <div class={classes!("min-w-0")}>
+                                                    <div class={classes!("text-sm", "font-semibold", "text-[var(--text)]")}>{ model.display_name.clone() }</div>
+                                                    <div class={classes!("mt-1", "break-all", "font-mono", "text-[11px]", "text-[var(--muted)]")}>{ model.id.clone() }</div>
+                                                </div>
+                                                <label class={classes!("text-sm")}>
+                                                    <div class={classes!("mb-1", "text-xs", "uppercase", "tracking-[0.16em]", "text-[var(--muted)]")}>{ "Preferred Group" }</div>
+                                                    <select
+                                                        class={classes!("w-full", "rounded-lg", "border", "border-[var(--border)]", "bg-[var(--surface)]", "px-3", "py-2", "text-sm")}
+                                                        value={selected_group_id}
+                                                        onchange={Callback::from(move |event: Event| {
+                                                            let input: HtmlSelectElement = event.target_unchecked_into();
+                                                            let selected = input.value();
+                                                            let mut next = (*model_group_preferences).clone();
+                                                            if selected.trim().is_empty() {
+                                                                next.remove(&model_id);
+                                                            } else {
+                                                                next.insert(model_id.clone(), selected);
+                                                            }
+                                                            model_group_preferences.set(next);
+                                                        })}
+                                                    >
+                                                        <option value="">{ "Default routing" }</option>
+                                                        { for account_groups.iter().map(|group| html! {
+                                                            <option value={group.id.clone()}>
+                                                                { format!("{} · {} accounts", group.name, group.account_count) }
+                                                            </option>
+                                                        }) }
+                                                    </select>
+                                                </label>
+                                            </div>
+                                        }
+                                    }) }
+                                </div>
+                            }
+                        </div>
+                        <div class={classes!("flex", "items-center", "justify-between", "gap-3", "border-t", "border-[var(--border)]", "px-5", "py-4", "flex-wrap")}>
+                            <button
+                                type="button"
+                                class={classes!("btn-terminal", "text-xs")}
+                                onclick={on_reset_model_group_preferences.clone()}
+                                disabled={*saving}
+                            >
+                                { "Reset" }
+                            </button>
+                            <div class={classes!("flex", "items-center", "gap-2", "flex-wrap")}>
+                                <button
+                                    type="button"
+                                    class={classes!("btn-terminal", "text-xs")}
+                                    onclick={{
+                                        let model_group_routing_open = model_group_routing_open.clone();
+                                        Callback::from(move |_| model_group_routing_open.set(false))
+                                    }}
+                                    disabled={*saving}
+                                >
+                                    { "Cancel" }
+                                </button>
+                                <button
+                                    type="button"
+                                    class={classes!("btn-terminal", "btn-terminal-primary", "text-xs")}
+                                    onclick={on_save_model_group_preferences.clone()}
+                                    disabled={*saving}
+                                >
+                                    { if *saving { "Saving..." } else { "Save Routing" } }
+                                </button>
+                            </div>
+                        </div>
+                    </section>
+                </div>
+            }
+
             <div class={classes!("mt-4", "flex", "items-center", "gap-2", "flex-wrap")}>
                 <button type="button" class={classes!("btn-terminal", "btn-terminal-primary")} onclick={on_save} disabled={*saving}>
                     { if *saving { "Saving..." } else { "Save" } }
diff --git a/crates/frontend/src/pages/admin_llm_gateway.rs b/crates/frontend/src/pages/admin_llm_gateway.rs
index 6c81e7b..5cd081c 100644
--- a/crates/frontend/src/pages/admin_llm_gateway.rs
+++ b/crates/frontend/src/pages/admin_llm_gateway.rs
@@ -1489,6 +1489,7 @@ fn key_editor_card(props: &KeyEditorCardProps) -> Html {
                     preferred_pool_strategy: None,
                     kiro_anthropic_upstream_pool_mode: None,
                     model_name_map: None,
+                    kiro_model_group_preferences: None,
                     request_max_concurrency: request_max_concurrency_value,
                     request_min_start_interval_ms: request_min_start_interval_ms_value,
                     codex_fast_enabled: Some(codex_fast_enabled_value),
diff --git a/crates/llm-access-core/src/store/empty.rs b/crates/llm-access-core/src/store/empty.rs
index 23af2d4..45efc8b 100644
--- a/crates/llm-access-core/src/store/empty.rs
+++ b/crates/llm-access-core/src/store/empty.rs
@@ -431,6 +431,7 @@ impl AdminKeyStore for EmptyAdminKeyStore {
             auto_account_names: None,
             preferred_pool_strategy: default_kiro_pool_strategy(),
             model_name_map: None,
+            kiro_model_group_preferences: std::collections::BTreeMap::new(),
             request_max_concurrency: key.request_max_concurrency,
             request_min_start_interval_ms: key.request_min_start_interval_ms,
             codex_fast_enabled: true,
diff --git a/crates/llm-access-core/src/store/keys.rs b/crates/llm-access-core/src/store/keys.rs
index 5c4bd3e..9f6e788 100644
--- a/crates/llm-access-core/src/store/keys.rs
+++ b/crates/llm-access-core/src/store/keys.rs
@@ -70,6 +70,9 @@ pub struct AdminKey {
     pub preferred_pool_strategy: String,
     /// Model name mapping.
     pub model_name_map: Option<BTreeMap<String, String>>,
+    /// Exact Kiro request-model to preferred account-group map.
+    #[serde(default)]
+    pub kiro_model_group_preferences: BTreeMap<String, String>,
     /// Per-key request concurrency cap.
     pub request_max_concurrency: Option<u64>,
     /// Per-key request pacing interval.
@@ -382,6 +385,8 @@ pub struct AdminKeyPatch {
     pub preferred_pool_strategy: Option<String>,
     /// New model name map.
     pub model_name_map: Option<Option<BTreeMap<String, String>>>,
+    /// New exact Kiro request-model to preferred account-group map.
+    pub kiro_model_group_preferences: Option<BTreeMap<String, String>>,
     /// New per-key request concurrency cap.
     pub request_max_concurrency: Option<Option<u64>>,
     /// New per-key request pacing interval.
@@ -455,6 +460,7 @@ mod tests {
             auto_account_names: None,
             preferred_pool_strategy: "balanced".to_string(),
             model_name_map: None,
+            kiro_model_group_preferences: BTreeMap::new(),
             request_max_concurrency: None,
             request_min_start_interval_ms: None,
             codex_fast_enabled: true,
diff --git a/crates/llm-access-core/src/store/kiro_model_routing.rs b/crates/llm-access-core/src/store/kiro_model_routing.rs
new file mode 100644
index 0000000..9a40dc5
--- /dev/null
+++ b/crates/llm-access-core/src/store/kiro_model_routing.rs
@@ -0,0 +1,68 @@
+//! Kiro model -> account-group preference helpers.
+//!
+//! ```text
+//! raw request model
+//!        |
+//!        +-- exact preference hit --> preferred account set
+//!        |
+//!        +-- no hit ---------------> existing affinity/order rules
+//! ```
+
+use std::collections::BTreeMap;
+
+/// Per-key exact model-name to Kiro account-group preference map.
+pub type KiroModelGroupPreferences = BTreeMap<String, String>;
+
+/// Normalize admin-supplied model preference rules.
+pub fn normalize_kiro_model_group_preferences(
+    input: KiroModelGroupPreferences,
+) -> KiroModelGroupPreferences {
+    input
+        .into_iter()
+        .filter_map(|(model, group_id)| {
+            let model = model.trim();
+            let group_id = group_id.trim();
+            (!model.is_empty() && !group_id.is_empty())
+                .then(|| (model.to_string(), group_id.to_string()))
+        })
+        .collect()
+}
+
+/// Resolve one exact model-name preference.
+pub fn kiro_model_group_preference<'a>(
+    preferences: &'a KiroModelGroupPreferences,
+    model: &str,
+) -> Option<&'a str> {
+    preferences.get(model.trim()).map(String::as_str)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn normalizes_model_group_preferences_by_trimming_and_dropping_empty_entries() {
+        let normalized = normalize_kiro_model_group_preferences(BTreeMap::from([
+            (" claude-sonnet-4 ".to_string(), " group-sonnet ".to_string()),
+            ("".to_string(), "group-empty-model".to_string()),
+            ("claude-opus-4".to_string(), " ".to_string()),
+        ]));
+
+        assert_eq!(
+            normalized,
+            BTreeMap::from([("claude-sonnet-4".to_string(), "group-sonnet".to_string())])
+        );
+    }
+
+    #[test]
+    fn resolves_model_group_preferences_by_exact_model_name() {
+        let preferences =
+            BTreeMap::from([("claude-sonnet-4".to_string(), "group-sonnet".to_string())]);
+
+        assert_eq!(
+            kiro_model_group_preference(&preferences, "claude-sonnet-4"),
+            Some("group-sonnet")
+        );
+        assert_eq!(kiro_model_group_preference(&preferences, "claude-sonnet"), None);
+    }
+}
diff --git a/crates/llm-access-core/src/store/mod.rs b/crates/llm-access-core/src/store/mod.rs
index 5aa9dc5..97c1ebc 100644
--- a/crates/llm-access-core/src/store/mod.rs
+++ b/crates/llm-access-core/src/store/mod.rs
@@ -14,6 +14,7 @@ mod empty;
 mod groups;
 mod keys;
 mod kiro_account;
+mod kiro_model_routing;
 mod proxy;
 mod public;
 mod routes;
@@ -71,6 +72,9 @@ pub use kiro_account::{
     ADMIN_KIRO_ACCOUNT_ISSUE_ABNORMAL, ADMIN_KIRO_ACCOUNT_ISSUE_AUTH_401,
     ADMIN_KIRO_ACCOUNT_ISSUE_DISABLED, ADMIN_KIRO_ACCOUNT_ISSUE_ERROR,
 };
+pub use kiro_model_routing::{
+    kiro_model_group_preference, normalize_kiro_model_group_preferences, KiroModelGroupPreferences,
+};
 pub use proxy::{
     default_proxy_bindings, AdminProxyBinding, AdminProxyConfig, AdminProxyConfigPatch,
     AdminProxyEndpointCheck, AdminProxyEndpointCheckUpdate, AdminProxyTrafficSnapshot,
diff --git a/crates/llm-access-core/src/store/routes.rs b/crates/llm-access-core/src/store/routes.rs
index 48f289d..bdd049f 100644
--- a/crates/llm-access-core/src/store/routes.rs
+++ b/crates/llm-access-core/src/store/routes.rs
@@ -1,6 +1,8 @@
 //! Provider routing contracts: authenticated key, provider proxy config,
 //! Codex/Kiro route + auth-update views, and JWT/auth-error helpers.
 
+use std::collections::BTreeMap;
+
 use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
 use serde_json::Value;
 
@@ -234,6 +236,8 @@ pub struct ProviderKiroRoute {
     pub cctest_proxy_api_key: Option<String>,
     /// JSON object mapping public model names to upstream Kiro model names.
     pub model_name_map_json: String,
+    /// Exact request-model to preferred account names resolved from key config.
+    pub model_group_preferred_account_names: BTreeMap<String, Vec<String>>,
     /// Effective Kiro cache k-model JSON for this key.
     pub cache_kmodels_json: String,
     /// Effective Kiro cache policy JSON for this key.
diff --git a/crates/llm-access-migrations/migrations/postgres/0001_init.sql b/crates/llm-access-migrations/migrations/postgres/0001_init.sql
index 75c54ff..974dde6 100644
--- a/crates/llm-access-migrations/migrations/postgres/0001_init.sql
+++ b/crates/llm-access-migrations/migrations/postgres/0001_init.sql
@@ -26,6 +26,9 @@ CREATE TABLE IF NOT EXISTS llm_key_route_config (
         preferred_pool_strategy IN ('balanced', 'credit_first')
     ),
     model_name_map_json JSONB,
+    kiro_model_group_preferences_json JSONB NOT NULL DEFAULT '{}'::jsonb CHECK (
+        jsonb_typeof(kiro_model_group_preferences_json) = 'object'
+    ),
     request_max_concurrency BIGINT,
     request_min_start_interval_ms BIGINT,
     codex_fast_enabled BOOLEAN NOT NULL DEFAULT TRUE,
diff --git a/crates/llm-access-migrations/migrations/postgres/0035_kiro_model_group_preferences.sql b/crates/llm-access-migrations/migrations/postgres/0035_kiro_model_group_preferences.sql
new file mode 100644
index 0000000..2dbe3d8
--- /dev/null
+++ b/crates/llm-access-migrations/migrations/postgres/0035_kiro_model_group_preferences.sql
@@ -0,0 +1,21 @@
+ALTER TABLE IF EXISTS llm_key_route_config
+    ADD COLUMN IF NOT EXISTS kiro_model_group_preferences_json JSONB NOT NULL DEFAULT '{}'::jsonb;
+
+UPDATE llm_key_route_config
+SET kiro_model_group_preferences_json = '{}'::jsonb
+WHERE kiro_model_group_preferences_json IS NULL
+   OR jsonb_typeof(kiro_model_group_preferences_json) <> 'object';
+
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1
+        FROM pg_constraint
+        WHERE conname = 'ck_llm_key_route_config_kiro_model_group_preferences_object'
+          AND conrelid = 'llm_key_route_config'::regclass
+    ) THEN
+        ALTER TABLE llm_key_route_config
+            ADD CONSTRAINT ck_llm_key_route_config_kiro_model_group_preferences_object
+            CHECK (jsonb_typeof(kiro_model_group_preferences_json) = 'object');
+    END IF;
+END $$;
diff --git a/crates/llm-access-migrations/src/lib.rs b/crates/llm-access-migrations/src/lib.rs
index 09e4d28..48747fd 100644
--- a/crates/llm-access-migrations/src/lib.rs
+++ b/crates/llm-access-migrations/src/lib.rs
@@ -178,6 +178,11 @@ const POSTGRES_MIGRATIONS: &[SqlMigration] = &[
         name: "anthropic_upstream_probe_state",
         sql: include_str!("../migrations/postgres/0034_anthropic_upstream_probe_state.sql"),
     },
+    SqlMigration {
+        version: 35,
+        name: "kiro_model_group_preferences",
+        sql: include_str!("../migrations/postgres/0035_kiro_model_group_preferences.sql"),
+    },
 ];
 
 /// Return target DuckDB migrations in execution order.
diff --git a/crates/llm-access-store/src/postgres.rs b/crates/llm-access-store/src/postgres.rs
index ad82b80..5abaf2b 100644
--- a/crates/llm-access-store/src/postgres.rs
+++ b/crates/llm-access-store/src/postgres.rs
@@ -775,7 +775,7 @@ impl ControlStore for PostgresControlRepository {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::OnceLock;
+    use std::{collections::HashSet, sync::OnceLock};
 
     use anyhow::Context;
     use llm_access_core::{
@@ -787,9 +787,9 @@ mod tests {
             AdminKiroAccountStore, AdminPageRequest, AdminProxyConfigPatch, AdminProxyStore,
             AdminProxyTrafficSnapshot, AdminReviewQueueStore, AnthropicUpstreamChannelUsageDelta,
             ControlStore, KeyUsageRollupDelta, NewAdminAnthropicUpstreamChannel,
-            NewAdminProxyConfig, NewPublicAccountContributionRequest, ProxyTrafficTotals,
-            PublicSubmissionStore, PublicUsageStore, UsageEventSink, UsageRollupBatch,
-            UsageRollupBatchSink,
+            NewAdminProxyConfig, NewPublicAccountContributionRequest, ProviderRouteStore,
+            ProxyTrafficTotals, PublicSubmissionStore, PublicUsageStore, UsageEventSink,
+            UsageRollupBatch, UsageRollupBatchSink,
         },
     };
     use serde::Serialize;
@@ -798,6 +798,7 @@ mod tests {
     use super::SqlxClient;
 
     static TEST_DB_LOCK: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
+    static TEST_DB_INITIALIZED: OnceLock<tokio::sync::Mutex<HashSet<String>>> = OnceLock::new();
 
     async fn test_db_guard() -> tokio::sync::MutexGuard<'static, ()> {
         TEST_DB_LOCK
@@ -806,10 +807,38 @@ mod tests {
             .await
     }
 
-    async fn reset_test_db(database_url: &str) -> anyhow::Result<()> {
-        crate::initialize_postgres_target(database_url)
+    fn test_db_initialization_key(database_url: &str) -> String {
+        format!("{:x}", Sha256::digest(database_url.as_bytes()))
+    }
+
+    fn mark_test_db_needs_initialization(
+        initialized: &mut HashSet<String>,
+        database_url: &str,
+    ) -> bool {
+        initialized.insert(test_db_initialization_key(database_url))
+    }
+
+    async fn ensure_test_db_schema(database_url: &str) -> anyhow::Result<()> {
+        let initialized =
+            TEST_DB_INITIALIZED.get_or_init(|| tokio::sync::Mutex::new(HashSet::new()));
+        let mut initialized = initialized.lock().await;
+        if !mark_test_db_needs_initialization(&mut initialized, database_url) {
+            return Ok(());
+        }
+
+        if let Err(error) = crate::initialize_postgres_target(database_url)
             .await
-            .context("initialize postgres test database")?;
+            .context("initialize postgres test database")
+        {
+            initialized.remove(&test_db_initialization_key(database_url));
+            return Err(error);
+        }
+
+        Ok(())
+    }
+
+    async fn reset_test_db(database_url: &str) -> anyhow::Result<()> {
+        ensure_test_db_schema(database_url).await?;
         let client = SqlxClient::connect(database_url)
             .await
             .context("connect postgres test database")?;
@@ -848,6 +877,24 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_db_initialization_marker_runs_once_per_database_url() {
+        let mut initialized = HashSet::new();
+
+        assert!(mark_test_db_needs_initialization(
+            &mut initialized,
+            "postgres://user:secret@localhost/one"
+        ));
+        assert!(!mark_test_db_needs_initialization(
+            &mut initialized,
+            "postgres://user:secret@localhost/one"
+        ));
+        assert!(mark_test_db_needs_initialization(
+            &mut initialized,
+            "postgres://user:secret@localhost/two"
+        ));
+    }
+
     async fn seed_test_key_bundle(database_url: &str) -> anyhow::Result<()> {
         let client = SqlxClient::connect(database_url)
             .await
@@ -1151,6 +1198,89 @@ mod tests {
         assert_eq!(key.key_name, "external");
     }
 
+    #[tokio::test]
+    async fn postgres_repository_skips_missing_kiro_model_group_preference() {
+        let Ok(database_url) = std::env::var("TEST_POSTGRES_URL") else {
+            eprintln!("skipping postgres integration test: TEST_POSTGRES_URL is not set");
+            return;
+        };
+        let _guard = test_db_guard().await;
+        reset_test_db(&database_url)
+            .await
+            .expect("reset postgres test database");
+        let client = SqlxClient::connect(&database_url)
+            .await
+            .expect("connect postgres test database");
+        let key_hash = format!("{:x}", Sha256::digest(b"kiro-secret"));
+        client
+            .execute(
+                "INSERT INTO llm_keys (
+                    key_id, name, secret, key_hash, status, provider_type, protocol_family,
+                    public_visible, quota_billable_limit, created_at_ms, updated_at_ms
+                 ) VALUES (
+                    'kiro-key', 'kiro', 'kiro-secret', $1, 'active', 'kiro', 'anthropic',
+                    TRUE, 1000, 1700000000000, 1700000000000
+                 )",
+                &[&key_hash],
+            )
+            .await
+            .expect("insert postgres kiro key");
+        client
+            .batch_execute(
+                "INSERT INTO llm_key_route_config (
+                    key_id, route_strategy, fixed_account_name, auto_account_names_json,
+                    account_group_id, preferred_pool_strategy, model_name_map_json,
+                    kiro_model_group_preferences_json, request_max_concurrency,
+                    request_min_start_interval_ms, codex_fast_enabled,
+                    kiro_request_validation_enabled, kiro_cache_estimation_enabled,
+                    kiro_zero_cache_debug_enabled, kiro_full_request_logging_enabled,
+                    kiro_cache_policy_override_json,
+                    kiro_billable_model_multipliers_override_json
+                 ) VALUES (
+                    'kiro-key', 'auto', NULL, '[\"kiro-a\"]'::jsonb, NULL, 'balanced', NULL,
+                    '{\"claude-sonnet-4\":\"missing-group\"}'::jsonb, NULL, NULL,
+                    TRUE, FALSE, FALSE, FALSE, FALSE, NULL, NULL
+                 );
+                 INSERT INTO llm_key_usage_rollups (
+                    key_id, input_uncached_tokens, input_cached_tokens, output_tokens,
+                    billable_tokens, credit_total, credit_missing_events, last_used_at_ms,
+                    updated_at_ms
+                 ) VALUES (
+                    'kiro-key', 0, 0, 0, 0, '0', 0, NULL, 1700000000000
+                 );
+                 INSERT INTO llm_kiro_accounts (
+                    account_name, auth_method, account_id, profile_arn, user_id,
+                    status, auth_json, max_concurrency, min_start_interval_ms,
+                    proxy_config_id, last_refresh_at_ms, last_error, created_at_ms, updated_at_ms
+                 ) VALUES (
+                    'kiro-a', 'social', NULL, NULL, 'user-a', 'active', '{}'::jsonb,
+                    1, 0, NULL, NULL, NULL, 1700000000000, 1700000000000
+                 );",
+            )
+            .await
+            .expect("insert postgres kiro route fixture");
+        client.close().await;
+        let repo = super::PostgresControlRepository::connect(&database_url, None)
+            .await
+            .expect("connect postgres repository");
+
+        let key = repo
+            .authenticate_bearer_secret("kiro-secret")
+            .await
+            .expect("authenticate kiro key")
+            .expect("kiro key must exist");
+        let routes = repo
+            .resolve_kiro_route_candidates(&key)
+            .await
+            .expect("resolve kiro route candidates");
+
+        assert_eq!(routes.len(), 1);
+        assert_eq!(routes[0].account_name, "kiro-a");
+        assert!(!routes[0]
+            .model_group_preferred_account_names
+            .contains_key("claude-sonnet-4"));
+    }
+
     #[tokio::test]
     async fn postgres_repository_manages_anthropic_upstream_channels_and_usage_rollups() {
         let Ok(database_url) = std::env::var("TEST_POSTGRES_URL") else {
diff --git a/crates/llm-access-store/src/postgres/cache.rs b/crates/llm-access-store/src/postgres/cache.rs
index 9321548..8fabc6e 100644
--- a/crates/llm-access-store/src/postgres/cache.rs
+++ b/crates/llm-access-store/src/postgres/cache.rs
@@ -484,6 +484,12 @@ impl PostgresControlRepository {
                     .collect(),
             )
             .await?;
+        let model_group_preferred_account_names = self
+            .resolve_kiro_model_group_preferred_account_names(
+                &bundle.route,
+                &selected_account_names,
+            )
+            .await?;
         let cache_policy_json = effective_kiro_cache_policy_json(
             &runtime_config.kiro_cache_policy_json,
             bundle.route.kiro_cache_policy_override_json.as_deref(),
@@ -503,6 +509,7 @@ impl PostgresControlRepository {
             anthropic_upstream_pool_mode: core_store::canonical_anthropic_upstream_pool_mode(Some(
                 &bundle.route.kiro_anthropic_upstream_pool_mode,
             )),
+            model_group_preferred_account_names,
             request_max_concurrency: bundle
                 .route
                 .request_max_concurrency
diff --git a/crates/llm-access-store/src/postgres/decode.rs b/crates/llm-access-store/src/postgres/decode.rs
index 97afb2f..f0f9ca0 100644
--- a/crates/llm-access-store/src/postgres/decode.rs
+++ b/crates/llm-access-store/src/postgres/decode.rs
@@ -117,6 +117,9 @@ fn decode_key_bundle(row: &PgRow) -> anyhow::Result<KeyBundle> {
                 .try_get_optional_string("preferred_pool_strategy")?
                 .unwrap_or_else(core_store::default_kiro_pool_strategy),
             model_name_map_json: row.get(15),
+            kiro_model_group_preferences_json: row
+                .try_get_optional_string("kiro_model_group_preferences_json")?
+                .or_else(|| Some("{}".to_string())),
             request_max_concurrency: row.get(16),
             request_min_start_interval_ms: row.get(17),
             codex_fast_enabled: row.get::<_, Option<bool>>(18).unwrap_or(true),
@@ -196,6 +199,10 @@ pub fn admin_key_from_bundle(bundle: &KeyBundle) -> AdminKey {
         auto_account_names: decode_optional_json(bundle.route.auto_account_names_json.as_deref()),
         preferred_pool_strategy: bundle.route.preferred_pool_strategy.clone(),
         model_name_map: decode_optional_json(bundle.route.model_name_map_json.as_deref()),
+        kiro_model_group_preferences: decode_optional_json(
+            bundle.route.kiro_model_group_preferences_json.as_deref(),
+        )
+        .unwrap_or_default(),
         request_max_concurrency: bundle
             .route
             .request_max_concurrency
diff --git a/crates/llm-access-store/src/postgres/keys.rs b/crates/llm-access-store/src/postgres/keys.rs
index b503b5c..ce7da8c 100644
--- a/crates/llm-access-store/src/postgres/keys.rs
+++ b/crates/llm-access-store/src/postgres/keys.rs
@@ -116,7 +116,9 @@ impl PostgresControlRepository {
                     r.kiro_cctest_text_handling_enabled
                         AS kiro_cctest_text_handling_enabled,
                     r.kiro_anthropic_upstream_pool_mode
-                        AS kiro_anthropic_upstream_pool_mode
+                        AS kiro_anthropic_upstream_pool_mode,
+                    r.kiro_model_group_preferences_json::text
+                        AS kiro_model_group_preferences_json
                  FROM llm_keys k
                  LEFT JOIN llm_key_route_config r ON r.key_id = k.key_id
                  LEFT JOIN llm_key_usage_rollups u ON u.key_id = k.key_id
@@ -167,7 +169,9 @@ impl PostgresControlRepository {
                     r.kiro_cctest_text_handling_enabled
                         AS kiro_cctest_text_handling_enabled,
                     r.kiro_anthropic_upstream_pool_mode
-                        AS kiro_anthropic_upstream_pool_mode
+                        AS kiro_anthropic_upstream_pool_mode,
+                    r.kiro_model_group_preferences_json::text
+                        AS kiro_model_group_preferences_json
                  FROM llm_keys k
                  LEFT JOIN llm_key_route_config r ON r.key_id = k.key_id
                  LEFT JOIN llm_key_usage_rollups u ON u.key_id = k.key_id
@@ -294,7 +298,9 @@ impl PostgresControlRepository {
                     r.kiro_cctest_text_handling_enabled
                         AS kiro_cctest_text_handling_enabled,
                     r.kiro_anthropic_upstream_pool_mode
-                        AS kiro_anthropic_upstream_pool_mode
+                        AS kiro_anthropic_upstream_pool_mode,
+                    r.kiro_model_group_preferences_json::text
+                        AS kiro_model_group_preferences_json
                  FROM llm_keys k
                  LEFT JOIN llm_key_route_config r ON r.key_id = k.key_id
                  LEFT JOIN llm_key_usage_rollups u ON u.key_id = k.key_id
@@ -376,6 +382,7 @@ impl PostgresControlRepository {
                             NULLIF(r.kiro_anthropic_upstream_pool_mode, ''),
                             'disabled'
                         ) AS kiro_anthropic_upstream_pool_mode,
+                        r.kiro_model_group_preferences_json,
                         g.account_names_json AS group_account_names_json,
                         COALESCE(NULLIF(r.route_strategy, ''), 'auto') AS route_strategy_norm
                     FROM llm_keys k
@@ -567,7 +574,9 @@ impl PostgresControlRepository {
                     page_keys.kiro_cctest_text_handling_enabled
                         AS kiro_cctest_text_handling_enabled,
                     page_keys.kiro_anthropic_upstream_pool_mode
-                        AS kiro_anthropic_upstream_pool_mode
+                        AS kiro_anthropic_upstream_pool_mode,
+                    page_keys.kiro_model_group_preferences_json::text
+                        AS kiro_model_group_preferences_json
                  FROM page_keys
                  LEFT JOIN key_candidate_summary summary
                    ON summary.key_id = page_keys.key_id
@@ -633,11 +642,26 @@ impl PostgresControlRepository {
                     r.kiro_cctest_text_handling_enabled
                         AS kiro_cctest_text_handling_enabled,
                     r.kiro_anthropic_upstream_pool_mode
-                        AS kiro_anthropic_upstream_pool_mode
+                        AS kiro_anthropic_upstream_pool_mode,
+                    r.kiro_model_group_preferences_json::text
+                        AS kiro_model_group_preferences_json
                  FROM llm_keys k
                  JOIN llm_key_route_config r ON r.key_id = k.key_id
                  LEFT JOIN llm_key_usage_rollups u ON u.key_id = k.key_id
-                 WHERE k.provider_type = $1 AND r.account_group_id = $2
+                 WHERE k.provider_type = $1
+                   AND (
+                        r.account_group_id = $2
+                        OR EXISTS (
+                            SELECT 1
+                            FROM jsonb_each_text(
+                                COALESCE(
+                                    r.kiro_model_group_preferences_json,
+                                    '{}'::jsonb
+                                )
+                            ) AS model_group(model_name, referenced_group_id)
+                            WHERE model_group.referenced_group_id = $2
+                        )
+                   )
                  ORDER BY k.created_at_ms DESC, k.key_id DESC
                  LIMIT 1",
                 &[&provider_type, &group_id],
@@ -705,11 +729,12 @@ impl PostgresControlRepository {
                     kiro_cctest_text_handling_enabled,
                     kiro_cache_policy_override_json,
                     kiro_billable_model_multipliers_override_json,
-                    kiro_anthropic_upstream_pool_mode
+                    kiro_anthropic_upstream_pool_mode,
+                    kiro_model_group_preferences_json
                  ) VALUES (
                     $1, $2, $3, $4::jsonb, $5, $6, $7::jsonb, $8, $9, $10, $11, $12,
                     $13, $14, $15, $16, $17, $18, $19, $20, $21, $22::jsonb, $23::jsonb,
-                    $24
+                    $24, COALESCE($25::jsonb, '{}'::jsonb)
                  )
                  ON CONFLICT(key_id) DO UPDATE SET
                     route_strategy = EXCLUDED.route_strategy,
@@ -745,7 +770,9 @@ impl PostgresControlRepository {
                     kiro_billable_model_multipliers_override_json =
                         EXCLUDED.kiro_billable_model_multipliers_override_json,
                     kiro_anthropic_upstream_pool_mode =
-                        EXCLUDED.kiro_anthropic_upstream_pool_mode",
+                        EXCLUDED.kiro_anthropic_upstream_pool_mode,
+                    kiro_model_group_preferences_json =
+                        EXCLUDED.kiro_model_group_preferences_json",
                 &[
                     &route.key_id,
                     &route.route_strategy,
@@ -771,6 +798,7 @@ impl PostgresControlRepository {
                     &route.kiro_cache_policy_override_json,
                     &route.kiro_billable_model_multipliers_override_json,
                     &route.kiro_anthropic_upstream_pool_mode,
+                    &route.kiro_model_group_preferences_json,
                 ],
             )
             .await
@@ -950,7 +978,9 @@ impl AdminKeyStore for PostgresControlRepository {
                 r.kiro_cctest_text_handling_enabled
                     AS kiro_cctest_text_handling_enabled,
                 r.kiro_anthropic_upstream_pool_mode
-                    AS kiro_anthropic_upstream_pool_mode
+                    AS kiro_anthropic_upstream_pool_mode,
+                r.kiro_model_group_preferences_json::text
+                    AS kiro_model_group_preferences_json
              FROM llm_keys k
              LEFT JOIN llm_key_route_config r ON r.key_id = k.key_id
              LEFT JOIN llm_key_usage_rollups u ON u.key_id = k.key_id
@@ -1022,6 +1052,7 @@ impl AdminKeyStore for PostgresControlRepository {
             account_group_id: None,
             preferred_pool_strategy: core_store::default_kiro_pool_strategy(),
             model_name_map_json: None,
+            kiro_model_group_preferences_json: Some("{}".to_string()),
             request_max_concurrency: key.request_max_concurrency.map(|value| value as i64),
             request_min_start_interval_ms: key
                 .request_min_start_interval_ms
@@ -1110,6 +1141,12 @@ impl AdminKeyStore for PostgresControlRepository {
                 .transpose()
                 .context("serialize postgres model name map")?;
         }
+        if let Some(value) = patch.kiro_model_group_preferences.as_ref() {
+            bundle.route.kiro_model_group_preferences_json = Some(
+                serde_json::to_string(value)
+                    .context("serialize postgres kiro model group preferences")?,
+            );
+        }
         if let Some(value) = patch.request_max_concurrency {
             bundle.route.request_max_concurrency = value.map(|value| value as i64);
         }
diff --git a/crates/llm-access-store/src/postgres/kiro_account.rs b/crates/llm-access-store/src/postgres/kiro_account.rs
index 3638878..54ede73 100644
--- a/crates/llm-access-store/src/postgres/kiro_account.rs
+++ b/crates/llm-access-store/src/postgres/kiro_account.rs
@@ -1747,6 +1747,7 @@ impl AdminKiroAccountStore for PostgresControlRepository {
             cctest_proxy_base_url: runtime_config.kiro_cctest_proxy_base_url,
             cctest_proxy_api_key: runtime_config.kiro_cctest_proxy_api_key,
             model_name_map_json: "{}".to_string(),
+            model_group_preferred_account_names: BTreeMap::new(),
             cache_kmodels_json: runtime_config.kiro_cache_kmodels_json,
             cache_policy_json: runtime_config.kiro_cache_policy_json,
             context_usage_min_request_tokens: runtime_config
diff --git a/crates/llm-access-store/src/postgres/routes.rs b/crates/llm-access-store/src/postgres/routes.rs
index 9cd02ee..9566d38 100644
--- a/crates/llm-access-store/src/postgres/routes.rs
+++ b/crates/llm-access-store/src/postgres/routes.rs
@@ -1,7 +1,7 @@
 //! Provider route-candidate reads, account-name resolution, and the
 //! `ProviderRouteStore` impl.
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 use anyhow::Context;
 use async_trait::async_trait;
@@ -434,6 +434,62 @@ impl PostgresControlRepository {
             other => anyhow::bail!("unsupported route strategy `{other}`"),
         }
     }
+
+    /// Resolve model preference group ids against the already-authorized key
+    /// candidate pool.
+    ///
+    /// ```text
+    /// key route config -> base candidates
+    /// model -> group id -> group accounts
+    ///                  \-> intersection with base candidates
+    /// ```
+    pub(super) async fn resolve_kiro_model_group_preferred_account_names(
+        &self,
+        route: &KeyRouteConfig,
+        selected_account_names: &[String],
+    ) -> anyhow::Result<BTreeMap<String, Vec<String>>> {
+        let raw_preferences = decode_optional_json::<BTreeMap<String, String>>(
+            route.kiro_model_group_preferences_json.as_deref(),
+        )
+        .unwrap_or_default();
+        let preferences = core_store::normalize_kiro_model_group_preferences(raw_preferences);
+        if preferences.is_empty() {
+            return Ok(BTreeMap::new());
+        }
+
+        let selected = selected_account_names
+            .iter()
+            .cloned()
+            .collect::<BTreeSet<_>>();
+        let mut resolved = BTreeMap::new();
+        for (model, group_id) in preferences {
+            let Some(group) = self.get_admin_account_group_row(&group_id).await? else {
+                tracing::warn!(
+                    group_id = %group_id,
+                    model = %model,
+                    "configured Kiro model group preference does not exist; skipping"
+                );
+                continue;
+            };
+            if group.provider_type != core_store::PROVIDER_KIRO {
+                tracing::warn!(
+                    group_id = %group_id,
+                    model = %model,
+                    provider_type = %group.provider_type,
+                    "configured Kiro model group preference belongs to a different provider; \
+                     skipping"
+                );
+                continue;
+            }
+            let account_names = group
+                .account_names
+                .into_iter()
+                .filter(|account_name| selected.contains(account_name))
+                .collect::<Vec<_>>();
+            resolved.insert(model, account_names);
+        }
+        Ok(resolved)
+    }
 }
 #[async_trait]
 impl ProviderRouteStore for PostgresControlRepository {
@@ -672,6 +728,9 @@ impl ProviderRouteStore for PostgresControlRepository {
                 cctest_proxy_base_url: snapshot.cctest_proxy_base_url.clone(),
                 cctest_proxy_api_key: snapshot.cctest_proxy_api_key.clone(),
                 model_name_map_json: snapshot.model_name_map_json.clone(),
+                model_group_preferred_account_names: snapshot
+                    .model_group_preferred_account_names
+                    .clone(),
                 cache_kmodels_json: snapshot.cache_kmodels_json.clone(),
                 cache_policy_json: snapshot.cache_policy_json.clone(),
                 context_usage_min_request_tokens: snapshot.context_usage_min_request_tokens,
@@ -858,6 +917,7 @@ impl ProviderRouteStore for PostgresControlRepository {
             cctest_proxy_base_url: runtime_config.kiro_cctest_proxy_base_url,
             cctest_proxy_api_key: runtime_config.kiro_cctest_proxy_api_key,
             model_name_map_json: "{}".to_string(),
+            model_group_preferred_account_names: BTreeMap::new(),
             cache_kmodels_json: runtime_config.kiro_cache_kmodels_json,
             cache_policy_json: runtime_config.kiro_cache_policy_json,
             context_usage_min_request_tokens: runtime_config
diff --git a/crates/llm-access-store/src/records.rs b/crates/llm-access-store/src/records.rs
index 04acf3d..b1546bc 100644
--- a/crates/llm-access-store/src/records.rs
+++ b/crates/llm-access-store/src/records.rs
@@ -58,6 +58,8 @@ pub struct KeyRouteConfig {
     pub preferred_pool_strategy: String,
     /// JSON object mapping public model names to upstream model names.
     pub model_name_map_json: Option<String>,
+    /// JSON object mapping exact Kiro request-model names to account-group ids.
+    pub kiro_model_group_preferences_json: Option<String>,
     /// Optional per-key concurrency cap.
     pub request_max_concurrency: Option<i64>,
     /// Optional per-key pacing interval.
diff --git a/crates/llm-access-store/src/request_cache.rs b/crates/llm-access-store/src/request_cache.rs
index 75a7621..84ef1f3 100644
--- a/crates/llm-access-store/src/request_cache.rs
+++ b/crates/llm-access-store/src/request_cache.rs
@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{collections::BTreeMap, time::Duration};
 
 use anyhow::Context;
 use llm_access_core::store::{
@@ -165,6 +165,10 @@ pub(crate) struct CachedKiroRequestSnapshot {
     /// still decode and keep old Kiro behavior.
     #[serde(default = "default_anthropic_upstream_pool_mode")]
     pub anthropic_upstream_pool_mode: String,
+    /// Exact request-model to preferred account names. Defaulted so older
+    /// Valkey payloads keep legacy affinity/ordering behavior.
+    #[serde(default)]
+    pub model_group_preferred_account_names: BTreeMap<String, Vec<String>>,
     pub request_max_concurrency: Option<u64>,
     pub request_min_start_interval_ms: Option<u64>,
     pub request_validation_enabled: bool,
diff --git a/crates/llm-access/src/admin.rs b/crates/llm-access/src/admin.rs
index 3eea6ea..883739f 100644
--- a/crates/llm-access/src/admin.rs
+++ b/crates/llm-access/src/admin.rs
@@ -588,6 +588,8 @@ pub(crate) struct PatchLlmGatewayKeyRequest {
     #[serde(default)]
     model_name_map: Option<BTreeMap<String, String>>,
     #[serde(default)]
+    kiro_model_group_preferences: Option<BTreeMap<String, String>>,
+    #[serde(default)]
     request_max_concurrency: Option<u64>,
     #[serde(default)]
     request_min_start_interval_ms: Option<u64>,
@@ -2612,6 +2614,9 @@ pub(crate) async fn patch_admin_kiro_key(
         Ok(patch) => patch,
         Err(response) => return response.into_response(),
     };
+    if let Err(response) = validate_kiro_model_group_preferences(&state, &patch).await {
+        return response.into_response();
+    }
     match state.admin_key_store.patch_admin_key(&key_id, patch).await {
         Ok(Some(key)) if key.provider_type == PROVIDER_KIRO => {
             match resolve_key_effective_kiro_cache_policy(&state, key).await {
@@ -6568,6 +6573,39 @@ fn select_kiro_candidate_account_names(
     }
 }
 
+async fn validate_kiro_model_group_preferences(
+    state: &HttpState,
+    patch: &AdminKeyPatch,
+) -> Result<(), AdminHttpError> {
+    let Some(preferences) = patch.kiro_model_group_preferences.as_ref() else {
+        return Ok(());
+    };
+    if preferences.is_empty() {
+        return Ok(());
+    }
+    let groups = state
+        .admin_account_group_store
+        .list_admin_account_groups(PROVIDER_KIRO)
+        .await
+        .map_err(|_| internal_error("Failed to load Kiro account groups"))?;
+    let group_ids = groups
+        .iter()
+        .map(|group| group.id.as_str())
+        .collect::<HashSet<_>>();
+
+    // model -> group id -> Kiro account group
+    // Rejecting bad links here keeps request routing deterministic.
+    for (model, group_id) in preferences {
+        if !group_ids.contains(group_id.as_str()) {
+            return Err(bad_request(&format!(
+                "kiro_model_group_preferences references unknown Kiro account group `{group_id}` \
+                 for model `{model}`"
+            )));
+        }
+    }
+    Ok(())
+}
+
 fn normalize_key_patch(
     request: PatchLlmGatewayKeyRequest,
 ) -> Result<AdminKeyPatch, AdminHttpError> {
@@ -6605,6 +6643,9 @@ fn normalize_key_patch(
         .as_deref()
         .map(normalize_anthropic_upstream_pool_mode_input)
         .transpose()?;
+    let kiro_model_group_preferences = request
+        .kiro_model_group_preferences
+        .map(core_store::normalize_kiro_model_group_preferences);
     let request_max_concurrency = if request.request_max_concurrency_unlimited {
         Some(None)
     } else {
@@ -6651,6 +6692,7 @@ fn normalize_key_patch(
         preferred_pool_strategy,
         kiro_anthropic_upstream_pool_mode,
         model_name_map: request.model_name_map.map(Some),
+        kiro_model_group_preferences,
         request_max_concurrency,
         request_min_start_interval_ms,
         codex_fast_enabled: request.codex_fast_enabled,
@@ -7963,6 +8005,7 @@ mod tests {
             preferred_pool_strategy: None,
             kiro_anthropic_upstream_pool_mode: None,
             model_name_map: None,
+            kiro_model_group_preferences: None,
             request_max_concurrency: None,
             request_min_start_interval_ms: None,
             request_max_concurrency_unlimited: false,
@@ -8013,6 +8056,7 @@ mod tests {
             auto_account_names: None,
             preferred_pool_strategy: core_store::default_kiro_pool_strategy(),
             model_name_map: None,
+            kiro_model_group_preferences: BTreeMap::new(),
             request_max_concurrency: None,
             request_min_start_interval_ms: None,
             codex_fast_enabled: true,
diff --git a/crates/llm-access/src/kiro_refresh.rs b/crates/llm-access/src/kiro_refresh.rs
index 2df4d8f..fde520d 100644
--- a/crates/llm-access/src/kiro_refresh.rs
+++ b/crates/llm-access/src/kiro_refresh.rs
@@ -934,6 +934,7 @@ mod tests {
             cctest_proxy_base_url: None,
             cctest_proxy_api_key: None,
             model_name_map_json: "{}".to_string(),
+            model_group_preferred_account_names: std::collections::BTreeMap::new(),
             cache_kmodels_json: llm_access_core::store::default_kiro_cache_kmodels_json(),
             cache_policy_json: llm_access_core::store::default_kiro_cache_policy_json(),
             context_usage_min_request_tokens:
diff --git a/crates/llm-access/src/kiro_status.rs b/crates/llm-access/src/kiro_status.rs
index 8506b27..91654b5 100644
--- a/crates/llm-access/src/kiro_status.rs
+++ b/crates/llm-access/src/kiro_status.rs
@@ -262,6 +262,7 @@ mod tests {
             cctest_proxy_base_url: None,
             cctest_proxy_api_key: None,
             model_name_map_json: "{}".to_string(),
+            model_group_preferred_account_names: std::collections::BTreeMap::new(),
             cache_kmodels_json: llm_access_core::store::default_kiro_cache_kmodels_json(),
             cache_policy_json: llm_access_core::store::default_kiro_cache_policy_json(),
             context_usage_min_request_tokens:
diff --git a/crates/llm-access/src/provider.rs b/crates/llm-access/src/provider.rs
index d2d42b8..971027b 100644
--- a/crates/llm-access/src/provider.rs
+++ b/crates/llm-access/src/provider.rs
@@ -33,7 +33,7 @@ mod usage_meta;
 mod util;
 
 use std::{
-    collections::{BTreeMap, HashMap},
+    collections::{BTreeMap, HashMap, HashSet},
     sync::{Arc, Mutex},
     time::{Duration, Instant},
 };
@@ -419,6 +419,8 @@ struct KiroWebsearchDispatch {
     kiro_session_affinity: Arc<KiroSessionAffinity>,
     kiro_latency_ranker: Arc<KiroLatencyRanker>,
     affinity_session_id: Option<String>,
+    requested_model: String,
+    model_group_preferred_account_names: Option<HashSet<String>>,
     request_input_tokens: i32,
     usage_meta: ProviderUsageMetadata,
 }
diff --git a/crates/llm-access/src/provider/kiro_dispatch.rs b/crates/llm-access/src/provider/kiro_dispatch.rs
index 0bd30d9..333dcae 100644
--- a/crates/llm-access/src/provider/kiro_dispatch.rs
+++ b/crates/llm-access/src/provider/kiro_dispatch.rs
@@ -87,6 +87,62 @@ use crate::kiro_refresh;
 const INCONSISTENT_ROUTE_CONFIGURATION_MESSAGE: &str = "Route configuration is inconsistent.";
 const KIRO_SAME_ACCOUNT_MAX_ATTEMPTS: usize = 3;
 
+fn kiro_model_group_preferred_account_names_for_model(
+    routes: &[ProviderKiroRoute],
+    requested_model: &str,
+) -> Option<HashSet<String>> {
+    let requested_model = requested_model.trim();
+    if requested_model.is_empty() {
+        return None;
+    }
+    routes
+        .first()
+        .and_then(|route| {
+            route
+                .model_group_preferred_account_names
+                .get(requested_model)
+        })
+        .map(|account_names| account_names.iter().cloned().collect())
+}
+
+fn log_kiro_model_group_preference_routing(
+    key: &AuthenticatedKey,
+    endpoint: &str,
+    requested_model: &str,
+    effective_model: &str,
+    model_preferred_account_names: Option<&HashSet<String>>,
+    preferred_account_name: Option<&str>,
+) {
+    let Some(model_preferred_account_names) = model_preferred_account_names else {
+        tracing::debug!(
+            key_id = %key.key_id,
+            key_name = %key.key_name,
+            endpoint = %endpoint,
+            requested_model = %requested_model,
+            effective_model = %effective_model,
+            "kiro model group routing preference not configured for request model"
+        );
+        return;
+    };
+    let mut preferred_account_names = model_preferred_account_names
+        .iter()
+        .map(String::as_str)
+        .collect::<Vec<_>>();
+    preferred_account_names.sort_unstable();
+    tracing::info!(
+        key_id = %key.key_id,
+        key_name = %key.key_name,
+        endpoint = %endpoint,
+        requested_model = %requested_model,
+        effective_model = %effective_model,
+        preferred_account_count = preferred_account_names.len(),
+        preferred_account_names = ?preferred_account_names,
+        sticky_affinity_account = preferred_account_name.unwrap_or(""),
+        sticky_affinity_ignored = preferred_account_name.is_some(),
+        "kiro model group routing preference is active"
+    );
+}
+
 fn route_private_prompt_safety(
     route: &ProviderKiroRoute,
     conversion: &ConversionResult,
@@ -243,6 +299,7 @@ pub async fn dispatch_kiro_proxy(
     };
     usage_meta.mark_pre_handler_done(clamp_duration_ms(parse_started.elapsed()));
     usage_meta.last_message_content = extract_last_message_from_kiro_messages(&payload);
+    let requested_model = payload.model.clone();
     if let Err(err) = apply_kiro_model_mapping(&routes[0].model_name_map_json, &mut payload) {
         return kiro_json_error(
             StatusCode::INTERNAL_SERVER_ERROR,
@@ -251,6 +308,8 @@ pub async fn dispatch_kiro_proxy(
         );
     }
     let effective_model = payload.model.clone();
+    let model_group_preferred_account_names =
+        kiro_model_group_preferred_account_names_for_model(&routes, &requested_model);
     let route_mcp_web_search = websearch::should_route_mcp_web_search(&payload);
     if !route_mcp_web_search {
         websearch::remove_web_search_tools(&mut payload);
@@ -403,6 +462,8 @@ pub async fn dispatch_kiro_proxy(
             kiro_session_affinity,
             kiro_latency_ranker,
             affinity_session_id,
+            requested_model,
+            model_group_preferred_account_names,
             request_input_tokens,
             usage_meta,
         })
@@ -485,6 +546,14 @@ pub async fn dispatch_kiro_proxy(
     let preferred_account_name = affinity_session_id
         .as_deref()
         .and_then(|session_id| kiro_session_affinity.lookup(&key.key_id, session_id));
+    log_kiro_model_group_preference_routing(
+        &key,
+        public_path,
+        &requested_model,
+        &effective_model,
+        model_group_preferred_account_names.as_ref(),
+        preferred_account_name.as_deref(),
+    );
     // New session (has a session id but no existing affinity): balance it onto
     // the least-bound account. Skipped for single-account keys (nothing to
     // spread). Computed once — affinity only mutates on success after the loop,
@@ -500,6 +569,7 @@ pub async fn dispatch_kiro_proxy(
             &failed_accounts,
             kiro_latency_ranker.as_ref(),
             preferred_account_name.as_deref(),
+            model_group_preferred_account_names.as_ref(),
             session_counts.as_ref(),
         )
         .await
@@ -1226,6 +1296,8 @@ async fn dispatch_kiro_websearch(input: KiroWebsearchDispatch) -> Response {
         kiro_session_affinity,
         kiro_latency_ranker,
         affinity_session_id,
+        requested_model,
+        model_group_preferred_account_names,
         request_input_tokens,
         mut usage_meta,
     } = input;
@@ -1262,6 +1334,14 @@ async fn dispatch_kiro_websearch(input: KiroWebsearchDispatch) -> Response {
     let preferred_account_name = affinity_session_id
         .as_deref()
         .and_then(|session_id| kiro_session_affinity.lookup(&key.key_id, session_id));
+    log_kiro_model_group_preference_routing(
+        &key,
+        "/mcp",
+        &requested_model,
+        payload.model.as_str(),
+        model_group_preferred_account_names.as_ref(),
+        preferred_account_name.as_deref(),
+    );
     // New session (has a session id but no existing affinity): balance it onto
     // the least-bound account. Skipped for single-account keys (nothing to
     // spread). Computed once — affinity only mutates on success after the loop,
@@ -1277,6 +1357,7 @@ async fn dispatch_kiro_websearch(input: KiroWebsearchDispatch) -> Response {
             &failed_accounts,
             kiro_latency_ranker.as_ref(),
             preferred_account_name.as_deref(),
+            model_group_preferred_account_names.as_ref(),
             session_counts.as_ref(),
         )
         .await
diff --git a/crates/llm-access/src/provider/route_selection.rs b/crates/llm-access/src/provider/route_selection.rs
index 2d7b473..8fb6f26 100644
--- a/crates/llm-access/src/provider/route_selection.rs
+++ b/crates/llm-access/src/provider/route_selection.rs
@@ -204,6 +204,7 @@ pub async fn select_kiro_route_with_account_permit(
     failed_accounts: &HashSet<String>,
     latency_ranker: &KiroLatencyRanker,
     preferred_account_name: Option<&str>,
+    model_preferred_account_names: Option<&HashSet<String>>,
     session_counts: Option<&HashMap<String, usize>>,
 ) -> Result<(ProviderKiroRoute, KiroRequestLease), Response> {
     if routes.is_empty() {
@@ -213,6 +214,8 @@ pub async fn select_kiro_route_with_account_permit(
             "kiro route is not configured",
         ));
     }
+    let model_preference_active =
+        model_preferred_account_names.is_some_and(|account_names| !account_names.is_empty());
     let queued_at = Instant::now();
     loop {
         let mut saw_local_limit = false;
@@ -221,7 +224,9 @@ pub async fn select_kiro_route_with_account_permit(
         let mut shortest_upstream_wait: Option<Duration> = None;
         let mut saw_candidate = false;
         let proxy_cooldowns = scheduler.proxy_cooldown_snapshot();
-        if let Some(preferred_route) = preferred_account_name
+        if let Some(preferred_route) = (!model_preference_active)
+            .then_some(())
+            .and(preferred_account_name)
             .and_then(|account_name| {
                 routes.iter().find(|route| {
                     route.account_name == account_name
@@ -252,11 +257,12 @@ pub async fn select_kiro_route_with_account_permit(
                 return Ok((preferred_route.clone(), permit));
             }
         }
-        for route in selection_ordered_kiro_routes(
+        for route in selection_ordered_kiro_routes_with_model_preference(
             routes,
             scheduler,
             latency_ranker,
             now_millis(),
+            model_preferred_account_names,
             session_counts,
         ) {
             if failed_accounts.contains(&route.account_name) {
@@ -398,20 +404,40 @@ pub async fn hydrate_kiro_route_for_dispatch(
 /// Ordering contract, highest precedence first:
 /// 1. proxy health: candidates whose proxy is in cooldown sort last (global, so
 ///    a throttled preferred-pool route never shadows a healthy fallback);
-/// 2. fewest bound affinity sessions (global; only active when `session_counts`
+/// 2. exact model-group preference, when configured for the request model;
+/// 3. fewest bound affinity sessions (global; only active when `session_counts`
 ///    is supplied for new-session balancing, inert otherwise);
-/// 3. pool rank: the key's preferred pool first, then the remaining pools in
+/// 4. pool rank: the key's preferred pool first, then the remaining pools in
 ///    `KIRO_POOL_STRATEGIES` order;
-/// 4. pool-specific tiebreakers — `balanced`: latency band, last-started,
+/// 5. pool-specific tiebreakers — `balanced`: latency band, last-started,
 ///    remaining credits desc; `credit_first`: remaining credits desc, latency
 ///    band, last-started;
-/// 5. account name, as the deterministic final tiebreaker.
+/// 6. account name, as the deterministic final tiebreaker.
+#[cfg(test)]
 pub fn selection_ordered_kiro_routes<'a>(
     routes: &'a [ProviderKiroRoute],
     scheduler: &KiroRequestScheduler,
     latency_ranker: &KiroLatencyRanker,
     now_ms: i64,
     session_counts: Option<&HashMap<String, usize>>,
+) -> Vec<&'a ProviderKiroRoute> {
+    selection_ordered_kiro_routes_with_model_preference(
+        routes,
+        scheduler,
+        latency_ranker,
+        now_ms,
+        None,
+        session_counts,
+    )
+}
+
+fn selection_ordered_kiro_routes_with_model_preference<'a>(
+    routes: &'a [ProviderKiroRoute],
+    scheduler: &KiroRequestScheduler,
+    latency_ranker: &KiroLatencyRanker,
+    now_ms: i64,
+    model_preferred_account_names: Option<&HashSet<String>>,
+    session_counts: Option<&HashMap<String, usize>>,
 ) -> Vec<&'a ProviderKiroRoute> {
     if routes.len() <= 1 {
         return routes.iter().collect();
@@ -422,6 +448,7 @@ pub fn selection_ordered_kiro_routes<'a>(
         route: &'a ProviderKiroRoute,
         pool_strategy: &'static str,
         proxy_in_cooldown: bool,
+        model_preferred: bool,
         session_count: Option<usize>,
         last_started_at: Option<Instant>,
         latency_band: Option<i64>,
@@ -466,6 +493,14 @@ pub fn selection_ordered_kiro_routes<'a>(
         }
     }
 
+    fn compare_model_preferred(left: bool, right: bool) -> Option<std::cmp::Ordering> {
+        match (left, right) {
+            (true, false) => Some(std::cmp::Ordering::Less),
+            (false, true) => Some(std::cmp::Ordering::Greater),
+            _ => None,
+        }
+    }
+
     fn compare_latency_band(left: Option<i64>, right: Option<i64>) -> Option<std::cmp::Ordering> {
         match (left, right) {
             (Some(left_band), Some(right_band)) => {
@@ -569,8 +604,10 @@ pub fn selection_ordered_kiro_routes<'a>(
         preferred_pool_strategy: &str,
     ) -> Ordering {
         // New-session spread stays global: pool preference only applies after
-        // proxy cooldown and active session count have been considered.
+        // proxy cooldown, model preference, and active session count have been
+        // considered.
         compare_proxy_cooldown(left.proxy_in_cooldown, right.proxy_in_cooldown)
+            .or_else(|| compare_model_preferred(left.model_preferred, right.model_preferred))
             .or_else(|| compare_session_count(left.session_count, right.session_count))
             .or_else(|| compare_pool_rank(left, right, preferred_pool_strategy))
             .or_else(|| compare_pool_tiebreakers(left, right))
@@ -644,6 +681,8 @@ pub fn selection_ordered_kiro_routes<'a>(
                 proxy_in_cooldown: proxy_key
                     .as_deref()
                     .is_some_and(|key| proxy_cooldowns.contains_key(key)),
+                model_preferred: model_preferred_account_names
+                    .is_some_and(|account_names| account_names.contains(&route.account_name)),
                 session_count: identity_session_counts.as_ref().map(|counts| {
                     counts
                         .get(route.routing_identity.as_str())
diff --git a/crates/llm-access/src/provider/tests.rs b/crates/llm-access/src/provider/tests.rs
index 1d624fd..7898d37 100644
--- a/crates/llm-access/src/provider/tests.rs
+++ b/crates/llm-access/src/provider/tests.rs
@@ -1552,6 +1552,7 @@ fn static_kiro_route() -> ProviderKiroRoute {
         cctest_proxy_base_url: None,
         cctest_proxy_api_key: None,
         model_name_map_json: "{}".to_string(),
+        model_group_preferred_account_names: BTreeMap::new(),
         cache_kmodels_json: llm_access_core::store::default_kiro_cache_kmodels_json(),
         cache_policy_json: llm_access_core::store::default_kiro_cache_policy_json(),
         context_usage_min_request_tokens:
@@ -1876,6 +1877,7 @@ async fn kiro_selection_prefers_sticky_account_when_immediately_available() {
         &ranker,
         Some("beta"),
         None,
+        None,
     )
     .await
     .expect("sticky beta should be selected");
@@ -1883,6 +1885,84 @@ async fn kiro_selection_prefers_sticky_account_when_immediately_available() {
     assert_eq!(route.account_name, "beta");
 }
 
+#[tokio::test]
+async fn kiro_selection_model_group_preference_outranks_sticky_account() {
+    let scheduler = llm_access_kiro::scheduler::KiroRequestScheduler::new();
+    let routes = vec![
+        kiro_route_for_selection("alpha", "user-alpha", 90.0, None),
+        kiro_route_for_selection("beta", "user-beta", 10.0, None),
+    ];
+    let ranker = crate::kiro_latency::KiroLatencyRanker::default();
+    let model_preferred_accounts = HashSet::from(["alpha".to_string()]);
+
+    let (route, _permit) = super::select_kiro_route_with_account_permit(
+        &scheduler,
+        &routes,
+        &HashSet::new(),
+        &ranker,
+        Some("beta"),
+        Some(&model_preferred_accounts),
+        None,
+    )
+    .await
+    .expect("model group preference should select alpha");
+
+    assert_eq!(route.account_name, "alpha");
+}
+
+#[tokio::test]
+async fn kiro_selection_model_group_preference_empty_set_keeps_sticky_account() {
+    let scheduler = llm_access_kiro::scheduler::KiroRequestScheduler::new();
+    let routes = vec![
+        kiro_route_for_selection("alpha", "user-alpha", 90.0, None),
+        kiro_route_for_selection("beta", "user-beta", 10.0, None),
+    ];
+    let ranker = crate::kiro_latency::KiroLatencyRanker::default();
+    let model_preferred_accounts = HashSet::new();
+
+    let (route, _permit) = super::select_kiro_route_with_account_permit(
+        &scheduler,
+        &routes,
+        &HashSet::new(),
+        &ranker,
+        Some("beta"),
+        Some(&model_preferred_accounts),
+        None,
+    )
+    .await
+    .expect("empty model group preference should keep sticky affinity");
+
+    assert_eq!(route.account_name, "beta");
+}
+
+#[tokio::test]
+async fn kiro_selection_model_group_preference_soft_falls_back_when_locally_throttled() {
+    let scheduler = llm_access_kiro::scheduler::KiroRequestScheduler::new();
+    let routes = vec![
+        kiro_route_for_selection("alpha", "user-alpha", 90.0, None),
+        kiro_route_for_selection("beta", "user-beta", 10.0, None),
+    ];
+    let _held = scheduler
+        .try_acquire("user-alpha", 1, 0, Instant::now())
+        .expect("alpha should be occupied");
+    let ranker = crate::kiro_latency::KiroLatencyRanker::default();
+    let model_preferred_accounts = HashSet::from(["alpha".to_string()]);
+
+    let (route, _permit) = super::select_kiro_route_with_account_permit(
+        &scheduler,
+        &routes,
+        &HashSet::new(),
+        &ranker,
+        None,
+        Some(&model_preferred_accounts),
+        None,
+    )
+    .await
+    .expect("available fallback account should be selected");
+
+    assert_eq!(route.account_name, "beta");
+}
+
 #[tokio::test]
 async fn kiro_selection_skips_sticky_account_when_locally_throttled() {
     let scheduler = llm_access_kiro::scheduler::KiroRequestScheduler::new();
@@ -1902,6 +1982,7 @@ async fn kiro_selection_skips_sticky_account_when_locally_throttled() {
         &ranker,
         Some("beta"),
         None,
+        None,
     )
     .await
     .expect("alpha should be selected without waiting for beta");
@@ -1937,6 +2018,7 @@ async fn kiro_selection_returns_rate_limit_when_all_accounts_are_upstream_cooled
             &ranker,
             None,
             None,
+            None,
         ),
     )
     .await
@@ -1982,6 +2064,7 @@ async fn kiro_selection_returns_rate_limit_when_preferred_account_is_upstream_co
             &ranker,
             Some("beta"),
             None,
+            None,
         ),
     )
     .await
@@ -2028,6 +2111,7 @@ async fn kiro_selection_rechecks_when_upstream_cooldown_expires_before_local_slo
             &ranker,
             None,
             None,
+            None,
         ),
     )
     .await
@@ -2168,6 +2252,7 @@ async fn kiro_selection_falls_back_when_preferred_pool_is_throttled() {
         &ranker,
         None,
         None,
+        None,
     )
     .await
     .expect("fallback balanced route should be selected");
@@ -2203,6 +2288,7 @@ async fn kiro_selection_keeps_sticky_account_across_pool_preference() {
         &ranker,
         Some("alpha"),
         None,
+        None,
     )
     .await
     .expect("sticky account should still win");