fix subagent default model config

src/agent/loop/AgentLoop.ts

@@ -406,7 +406,7 @@ export class AgentLoop {
 
       let pendingContextBudget: TokenBudgetSnapshot | undefined;
       const ctx = this.dependencies.context;
-      const preRoutingMaxContextTokens = this.currentMaxContextTokens(this.config.provider, this.config.model);
+      const preRoutingMaxContextTokens = this.preRoutingMaxContextTokens();
       if (ctx?.tryAutoCompact) {
         try {
           const reservedOutputTokens = this.getReservedOutputTokens();
@@ -2012,16 +2012,27 @@ export class AgentLoop {
   private currentMaxContextTokens(provider: string, model: string): number {
     const transient = this.transientTokenCaps.get(this.tokenCapKey(provider, model))?.maxContextTokens;
     return transient
-      ?? this.config.maxContextTokens
+      ?? this.getBaselineSubagentTokenLimits(provider, model)?.maxContextTokens
+      ?? this.currentConfigMaxContextTokens()
       ?? this.dependencies.getModelMaxContextTokens?.(provider, model)
       ?? this.getModelTokenLimits(provider, model)?.maxContextTokens
       ?? 1_000_000;
   }
 
+  private preRoutingMaxContextTokens(): number {
+    if (this.config.isSubagent && this.config.subagentModel) {
+      return 1_000_000;
+    }
+    return this.currentMaxContextTokens(this.config.provider, this.config.model);
+  }
+
   private currentMaxOutputTokens(provider: string, model: string): number | undefined {
     const transient = this.transientTokenCaps.get(this.tokenCapKey(provider, model));
     const modelMaxOutputTokens = this.getModelTokenLimits(provider, model)?.maxOutputTokens;
-    const requested = transient?.attemptMaxOutputTokens ?? transient?.requestedMaxOutputTokens ?? this.config.maxOutputTokens;
+    const requested = transient?.attemptMaxOutputTokens
+      ?? transient?.requestedMaxOutputTokens
+      ?? this.getBaselineSubagentTokenLimits(provider, model)?.maxOutputTokens
+      ?? this.currentConfigMaxOutputTokens();
     const candidates = [requested, transient?.hardMaxOutputTokens]
       .filter((value): value is number => typeof value === "number" && Number.isFinite(value) && value > 0);
     if (candidates.length > 0 && typeof modelMaxOutputTokens === "number" && Number.isFinite(modelMaxOutputTokens) && modelMaxOutputTokens > 0) {
@@ -2030,6 +2041,34 @@ export class AgentLoop {
     return candidates.length > 0 ? Math.min(...candidates.map((value) => Math.floor(value))) : undefined;
   }
 
+  private getBaselineSubagentTokenLimits(provider: string, model: string): { maxContextTokens?: number; maxOutputTokens?: number } | undefined {
+    if (this.config.isSubagent !== true) {
+      return undefined;
+    }
+    const baseline = this.config.subagentModel;
+    if (!baseline || baseline.provider !== provider || baseline.model !== model) {
+      return undefined;
+    }
+    return {
+      maxContextTokens: baseline.maxContextTokens,
+      maxOutputTokens: baseline.maxOutputTokens,
+    };
+  }
+
+  private currentConfigMaxContextTokens(): number | undefined {
+    if (this.config.isSubagent && this.config.subagentModel) {
+      return undefined;
+    }
+    return this.config.maxContextTokens;
+  }
+
+  private currentConfigMaxOutputTokens(): number | undefined {
+    if (this.config.isSubagent && this.config.subagentModel) {
+      return undefined;
+    }
+    return this.config.maxOutputTokens;
+  }
+
   private setTransientTokenCap(provider: string, model: string, cap: {
     maxContextTokens?: number;
     requestedMaxOutputTokens?: number;

src/agent/runtime/AgentRuntimeConfig.ts

@@ -42,6 +42,14 @@ export type AgentRuntimeConfig = {
    * but no nested forks). Increase only when intentional.
    */
   maxSubagentDepth?: number;
+  /** Optional default model/caps for forked subagents. Omitted means inherit this agent's model. */
+  subagentModel?: {
+    provider: string;
+    model: string;
+    modelMultimodal?: MultimodalConstraints;
+    maxContextTokens?: number;
+    maxOutputTokens?: number;
+  };
   /** Optional timeout budget for forked subagents spawned by the `agent` tool. */
   subagentTimeoutMs?: number;
   /** Enable automatic JSON self-correction retry on invalid_tool_arguments. Default false. */

src/agent/sub/SubAgentSession.ts

@@ -278,6 +278,12 @@ export class SubAgentSession {
 
   private buildConfig(): AgentRuntimeConfig {
     const parent = this.options.parentConfig;
+    const subagentModel = parent.subagentModel;
+    const {
+      maxContextTokens: _parentMaxContextTokens,
+      maxOutputTokens: _parentMaxOutputTokens,
+      ...parentWithoutTokenCaps
+    } = parent;
     const subagentSystem = buildSubagentSystemPrompt(this.options.definition);
     const filteredParentSystem = applySystemPromptFilters(
       parent.systemPrompt ?? "",
@@ -287,11 +293,21 @@ export class SubAgentSession {
       ? `${subagentSystem}\n\n${filteredParentSystem}`
       : subagentSystem;
     return {
-      ...parent,
+      ...(subagentModel ? parentWithoutTokenCaps : parent),
+      ...(subagentModel
+        ? {
+            provider: subagentModel.provider,
+            model: subagentModel.model,
+            ...(subagentModel.modelMultimodal
+              ? { modelMultimodal: subagentModel.modelMultimodal }
+              : {}),
+          }
+        : {}),
       // Ask mode performs read-only checks against each tool call's real
       // input. Do not probe dynamic isReadOnly implementations with a dummy
       // object while constructing the registry.
       runMode: this.isReadOnlySession() ? "ask" : parent.runMode,
+      isSubagent: true,
       permissionContext: {
         ...parent.permissionContext,
         rules: {

src/cli/createLocalGateway.ts

@@ -1416,13 +1416,48 @@ class ProjectRuntimeRegistry {
     maxOutputTokens = readPositiveIntegerEnv(this.options.env.PILOTDECK_MAX_OUTPUT_TOKENS)
       ?? agent.maxOutputTokens
       ?? maxOutputTokens;
+    const subagentModel = agent.subagents?.default;
+    let subagentRuntimeModel: CreateAgentSessionOptions["config"]["subagentModel"];
+    if (subagentModel) {
+      let subagentModelMultimodal: import("../model/index.js").MultimodalConstraints | undefined;
+      try {
+        subagentModelMultimodal = runtime.model.getMultimodal(
+          subagentModel.provider,
+          subagentModel.model,
+        );
+      } catch {
+        // Model or provider not found — keep the override but fall back to inherited caps.
+      }
+      let subagentMaxContextTokens: number | undefined;
+      let subagentMaxOutputTokens: number | undefined;
+      try {
+        const caps = runtime.model.getCapabilities(subagentModel.provider, subagentModel.model);
+        subagentMaxContextTokens = caps.maxContextTokens;
+        subagentMaxOutputTokens = caps.maxOutputTokens;
+      } catch {
+        // Keep the override even if capability lookup fails.
+      }
+      subagentRuntimeModel = {
+        provider: subagentModel.provider,
+        model: subagentModel.model,
+        ...(subagentModelMultimodal ? { modelMultimodal: subagentModelMultimodal } : {}),
+        ...(subagentMaxContextTokens !== undefined ? { maxContextTokens: subagentMaxContextTokens } : {}),
+        ...(subagentMaxOutputTokens !== undefined
+          ? {
+              maxOutputTokens: readPositiveIntegerEnv(this.options.env.PILOTDECK_MAX_OUTPUT_TOKENS)
+                ?? subagentMaxOutputTokens,
+            }
+          : {}),
+      };
+    }
     return {
       provider: agent.model.provider,
       model: agent.model.model,
       modelMultimodal,
       cwd,
       permissionMode,
       jsonSelfCorrect: true,
+      ...(subagentRuntimeModel ? { subagentModel: subagentRuntimeModel } : {}),
       subagentTimeoutMs: agent.subagents?.timeoutMs,
       maxContextTokens,
       maxOutputTokens,

src/pilot/config/loadPilotConfig.ts

@@ -346,7 +346,7 @@ function parseAgent(
   }
 
   const model = parseAgentModelSelection(rawAgent.model, "agent.model", modelConfig, diagnostics);
-  const subagents = parseAgentSubagents(rawAgent.subagents, diagnostics);
+  const subagents = parseAgentSubagents(rawAgent.subagents, modelConfig, diagnostics);
   const maxContextTokens = readOptionalPositiveInteger(rawAgent.maxContextTokens, "agent.maxContextTokens");
   const maxOutputTokens = readOptionalPositiveInteger(rawAgent.maxOutputTokens, "agent.maxOutputTokens");
   const thinking = parseAgentThinking(rawAgent.thinking);
@@ -383,6 +383,7 @@ function parseAgentThinking(value: unknown): PilotAgentConfig["thinking"] | unde
 
 function parseAgentSubagents(
   value: unknown,
+  modelConfig: ReturnType<typeof parseModel>,
   diagnostics: PilotConfigDiagnostic[],
 ): PilotAgentConfig["subagents"] | undefined {
   if (value === undefined) {
@@ -392,7 +393,7 @@ function parseAgentSubagents(
     throw new PilotConfigError("CONFIG_AGENT_SUBAGENTS_INVALID", "agent.subagents must be an object.");
   }
   for (const key of Object.keys(value)) {
-    if (key !== "timeoutMs") {
+    if (key !== "timeoutMs" && key !== "default" && key !== "params") {
       diagnostics.push({
         code: "CONFIG_AGENT_UNKNOWN_FIELD",
         severity: "warning",
@@ -402,11 +403,86 @@ function parseAgentSubagents(
       });
     }
   }
+  let defaultModel: PilotAgentModelSelection | undefined;
+  if (value.default !== undefined && value.default !== null) {
+    if (typeof value.default === "string" && value.default.trim() === "inherit") {
+      defaultModel = undefined;
+    } else {
+      defaultModel = parseSubagentDefaultModelSelection(
+        value.default,
+        modelConfig,
+        diagnostics,
+      );
+    }
+  }
   return {
+    ...(defaultModel ? { default: defaultModel } : {}),
     timeoutMs: readOptionalPositiveInteger(value.timeoutMs, "agent.subagents.timeoutMs"),
   };
 }
 
+function parseSubagentDefaultModelSelection(
+  value: unknown,
+  modelConfig: ReturnType<typeof parseModel>,
+  diagnostics: PilotConfigDiagnostic[],
+): PilotAgentModelSelection | undefined {
+  const path = "agent.subagents.default";
+  if (typeof value !== "string" || value.trim().length === 0) {
+    diagnostics.push({
+      code: "CONFIG_AGENT_SUBAGENT_MODEL_INVALID",
+      severity: "warning",
+      message: `${path} must be inherit or a provider/model string. Inheriting agent.model instead.`,
+      path,
+      recoverable: true,
+    });
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+  const separatorIndex = trimmed.indexOf("/");
+  const providerId = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex) : "";
+  const modelId = separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1) : "";
+  if (!providerId || !modelId) {
+    diagnostics.push({
+      code: "CONFIG_AGENT_SUBAGENT_MODEL_INVALID",
+      severity: "warning",
+      message: `${path} must use provider/model format. Inheriting agent.model instead.`,
+      path,
+      recoverable: true,
+    });
+    return undefined;
+  }
+
+  const provider = modelConfig.providers[providerId];
+  if (!provider) {
+    diagnostics.push({
+      code: "CONFIG_AGENT_SUBAGENT_PROVIDER_NOT_FOUND",
+      severity: "warning",
+      message: `${path} references unknown provider ${providerId}. Inheriting agent.model instead.`,
+      path,
+      recoverable: true,
+    });
+    return undefined;
+  }
+
+  if (!provider.models[modelId]) {
+    diagnostics.push({
+      code: "CONFIG_AGENT_SUBAGENT_MODEL_NOT_FOUND",
+      severity: "warning",
+      message: `${path} references unknown model ${modelId} for provider ${providerId}. Inheriting agent.model instead.`,
+      path,
+      recoverable: true,
+    });
+    return undefined;
+  }
+
+  return {
+    id: trimmed,
+    provider: providerId,
+    model: modelId,
+  };
+}
+
 function parseAgentModelSelection(
   value: unknown,
   path: string,

src/pilot/config/types.ts

@@ -74,6 +74,7 @@ export type PilotAgentConfig = {
   maxOutputTokens?: number;
   thinking?: { enabled: boolean; budgetTokens?: number };
   subagents?: {
+    default?: PilotAgentModelSelection;
     timeoutMs?: number;
   };
 };