Why Agent Models Score Higher with Minimal Toolsets: Policy Bias, Not Overfitting

    Agent models often behave differently depending on the toolset exposed to them. This article examines why the same model weights can appear more stable and score higher under a minimal toolset, usually limited to command-line execution and file editing, while becoming less reliable when dozens of tools, sub-agent dispatch, and task-planning components are available. It argues that high scores in minimal mode are better explained by policy bias than by narrow overfitting to minimal prompts or tools. The article clarifies key concepts, explains the underlying action-space and preference-optimization mechanisms, proposes controlled diagnostic experiments, lists measurable engineering indicators, and provides practical recommendations for building more stable multi-tool agents.

    1. Problem Background: Same Weights, Different Toolsets, Different Performance

    In engineering work with agentic models, one pattern appears repeatedly. With the same model weights, a “minimal toolset” configuration—typically exposing only command-line execution and file editing—often produces stable behavior and compact execution. When the same model is moved to a “full toolset”—with dozens of tools, sub-agent dispatch, and task-planning components—it is more likely to show the following problems:

    • Decision hesitation: repeatedly weighing multiple candidate tools and trying different paths for the same goal.
    • Path divergence: drifting away from the original goal after reaching the middle of a task, or making unnecessary changes to unrelated files.
    • Tool hallucination: calling tools that do not exist or using mismatched tool signatures and parameters.
    • Idle loops: repeatedly reading, modifying, and re-reading the same file without moving on to verification.
    • Task failure: individual steps look correct, but the overall task does not converge.

    This raises a sharp question: Does a better score in minimal mode prove that the model overfit during post-training to minimal prompts and minimal toolsets?

    This article advances a testable claim:

    1. Narrow overfitting does not hold. A post-trained model’s preference for “few tools and linear tool chains” does not prove that it only memorized minimal prompts or a minimal toolset.
    2. Policy bias exists. Post-training—especially reinforcement learning centered on outcome rewards—strengthens the behavioral pattern of reaching the goal through a few critical operations. This pattern naturally fits a minimal toolset, but adapts poorly to high-freedom tool environments.
    3. High scores in minimal mode have a reasonable mechanism, but do not necessarily indicate stronger general agent capability. To judge model strength, one must look at the actual performance it can reliably deliver in the target environment.

    The rest of the article first clarifies core concepts, then argues from training, mechanism, and preference perspectives. Finally, it provides diagnostic methods, evaluation standards, and engineering recommendations.

    2. Concept Clarification: Minimal Toolsets, Overfitting, and Policy Bias

    2.1 Two toolset modes

    Dimension Minimal toolset Full toolset
    Number of tools A few categories, such as command-line execution and file editing Dozens, including retrieval, dispatch, and planning
    Auxiliary components No sub-agents, no task planning Sub-agent dispatch, task planning, etc.
    Action space Small, with fewer decision branches Large, with more decision branches
    Environment nature Controlled, homogeneous, reproducible Open, heterogeneous, with complex state
    Typical use Benchmark baselines, lightweight local automation Complex development, cross-repository collaboration, production scenarios
    Main risk Capability ceiling constrained by the environment Amplified decision noise and lower stability

    It is important to note that a minimal toolset is not necessarily “less capable”. Instead, it places the model on a highly controlled test bench:

    • The external environment is unified as “command line + file editing”.
    • Feedback signals are simple and clear.
    • Successful paths are limited and enumerable.

    High scores measured in such environments are essentially conditional conclusions. They hold only under the current configuration combination.

    2.2 The strict meaning of overfitting

    Overfitting describes a statistical failure to generalize. It usually depends on three conditions:

    1. Training and evaluation distributions overlap heavily, so evaluation resembles an open-book test on training data.
    2. The model memorizes details of training samples, rather than learning transferable patterns.
    3. Performance drops significantly when the distribution changes, meaning generalization error exceeds training error.

    In the context of this article, “overfitting to minimal mode” would mean: the model has been repeatedly reinforced on minimal prompts, minimal toolsets, and minimal task distributions, and its performance noticeably declines when faced with other tool configurations.

    2.3 Three phenomena often confused with overfitting

    Phenomenon Nature Typical behavior Relationship to overfitting
    Policy bias The policy distribution concentrates into a narrow behavior pattern Can complete tasks, but prefers fixed short paths Different: this is a preference, not memorization
    Covariate shift Runtime environment, such as toolset or environment configuration, differs from training environment Behavior patterns change with environment configuration Different: this is an input-environment change
    Target-task bias Optimization focuses on a specific task distribution Good on target tasks, weaker on other tasks Related: this is task-level overfitting

    Distinguishing these cases is critical. Misclassifying policy bias or environment shift as overfitting can lead to wrong decisions, such as prematurely dismissing a model’s multi-tool ability, or blindly adding many minimal trajectories for “corrective” training.

    3. Core Judgment: High Scores in Minimal Mode Are More Likely Due to Policy Bias

    The conclusion comes first: without direct evidence that training data consists only of minimal-environment trajectories, the inference “high score in minimal mode = overfitting to minimal mode” does not hold.

    A more reasonable explanation has three layers:

    • Training coverage: multi-tool decision making is not entirely unseen.
    • Action space: a minimal toolset significantly reduces the difficulty of searching for and executing effective strategies.
    • Preference optimization: outcome-oriented reinforcement learning naturally rewards short paths, reinforcing linear tool-chain patterns.

    3.1 Training pipeline: post-training is not limited to minimal environments

    In publicly described industry practice, reinforcement learning data for agent models generally covers multiple scenarios, including:

    • “locate → modify → verify” chains with few tools.
    • Multi-tool collaboration, information retrieval, and tool combination.
    • Sub-agent collaboration and long-horizon task decomposition.
    • Error recovery across multiple tool calls.

    Therefore, from the perspective of training-data coverage, the model is not lacking multi-tool decision samples. The premise that it was trained “only in minimal mode” is hard to establish.

    It should be stated honestly: this is a reasonable inference based on publicly described industry practice and cannot replace verification of a specific model’s training recipe.

    In addition, public post-training materials usually do not include the full reproduction configuration of “minimal prompt template + minimal toolset”. A high score in minimal mode is more likely the result of several factors working together:

    • The reasoning chain is clean.
    • The convergence path is short.
    • The model’s capability is fully released in a controlled environment.

    This only shows that minimal mode is a good observation window for the model’s strengths, not a training-exclusive region for its capability.

    3.2 Mechanism: why models “think more clearly” with fewer tools

    From a policy perspective, agent behavior is determined by the policy $\pi(a \mid s)$: $s$ is the environment state, including the task description, available tools and their descriptions, and historical operations; $a$ is the next action, calling a tool with parameters. The toolset is essentially the action space of the policy.

    If each step has $k$ available actions and a task requires $n$ effective steps, then, roughly speaking, the size of the action space for a full trajectory is on the order of $k^n$. If a minimal toolset has $k_0$ available actions per step, then from combinatorial size alone, the action space expands by about $(k/k_0)^n$ times. Real action spaces also include parameter values and multi-tool sequences, so the difference can only be larger.

    The following pseudocode simulates this intuition. It is illustrative and does not correspond to any specific product.

    1. def evaluate_modes(tasks, policies, k_min=3, k_full=15, n_steps=5, trials=200):
    2. # Approximate toolset-size differences by the number of available actions per step.
    3. # This is used only to illustrate relative trends.
    4. for k in (k_min, k_full):
    5. outcome = {"success": 0, "avg_steps": 0.0, "max_steps": 0}
    6. for policy in policies: # same weights, two different training regimes
    7. for _ in range(trials):
    8. state, steps, repeated = initial_state(), 0, 0
    9. done = False
    10. while not done and steps < n_steps * 4: # step limit
    11. action = sample(policy, state, action_num=k)
    12. done, ok = step(state, action)
    13. steps += 1
    14. repeated += same_as_previous(state, action) # repeated probing
    15. outcome["success"] += int(done and ok)
    16. outcome["avg_steps"] += steps
    17. outcome["max_steps"] = max(outcome["max_steps"], steps)
    18. print(k, {key: round(value / trials, 3) for key, value in outcome.items()})
    • Result-oriented policies: a high-entropy policy $\pi_1$ explores uniformly across $k$ actions at each step and prefers “observe more and try more”.
    • Goal-aligned policies: a low-entropy policy $\pi_2$ follows a verified main path with relatively high probability, 0.85, and tries randomly with the remaining probability; it prefers “locate first, make minimal changes, then verify”.

    When $k=3$, $\pi_1$ can occasionally guess the correct path. When $k=15$, the probability that the high-entropy policy gets five steps correct in a row is about $(1/15)^5 \approx 1.3 \times 10^{-6}$, while for the low-entropy policy it is about $0.85^5 \approx 44\%$. The gap between the two policies expands from “close” to “an order of magnitude”.

    These success rates and step counts are teaching examples, not measured data from any real model. However, they reveal a repeatedly validated mechanism:

    In open tool environments, the outcome often depends not on whether the model “can do it”, but on whether it can reliably select the “shortest correct path”.

    This can be summarized in five aspects:

    1. Decision-branch effect (branching-factor amplification): more tools mean more options at each step. If tool granularity varies or boundaries are blurry, variance in “which tool to choose” can grow sharply.
    2. State-space dimensionality effect: multi-tool environments introduce more environment states, such as retrieval results, sub-agent feedback, and planning artifacts. As context becomes longer and more heterogeneous, attention weights on key information are more easily diluted.
    3. Exploration-exploitation imbalance: a full toolset naturally provides exploration channels. Under outcome-oriented training, policies tend to “try first and think later”, producing dense small-step probing that consumes the step budget meant for real task progress.
    4. State-management cost of composite tools: dispatching sub-agents and generating or maintaining plans requires extra state management. Some models use extended thinking to produce longer internal reasoning; once length exceeds effective capacity, problems such as “thinking more and doing less” or inconsistency can appear. If any component is mismatched, errors propagate downstream.
    5. Policy concentration under surface constraints: when tools are few and available paths are limited, even a high-entropy policy may still land on a small set of effective sequences after multiple sampling steps. In this case, the model’s policy overlaps strongly with the “task-optimal solution”, appearing as strong convergence and high scores.

    For point 5, the relationship between entropy and expected return helps intuition:

    • For a policy with entropy $H$, $\mathbb{E}[R] \le R_{\max} - c \cdot H$, which suggests that a more dispersed policy has a lower upper bound on expected return.
    • Using the Gumbel-max trick, softmax sampling can be viewed as adding perturbations to action values and then taking the maximum. From an energy-entropy perspective, sampling probability is approximately proportional to $\exp((Q(a) + \varepsilon_a)/\tau)$, and the approximate expected return does not exceed $\tau \log \sum_a \exp(Q(a)/\tau)$.

    Intuitively, the more actions there are and the more dispersed the policy is, the more high scores depend on sampling luck. When actions are few and a clear optimal path exists, the loss caused by policy divergence is smaller. This is the first-principles reason why the same weights are more stable under a minimal toolset.

    3.3 Preference optimization: reinforcement learning rewards outcomes, not “few tools”

    Post-training reinforcement learning centered on verifiable outcome rewards—such as whether a task is completed or whether tests pass—structurally rewards “efficiency in achieving the goal”.

    • In minimal tool environments, efficient trajectories are naturally short and clear, easily receive high rewards, and are repeatedly reinforced as positive samples.
    • In multi-tool environments, trajectories that complete the same task may be longer and have more branches, diluting the “average advantage” per step.
    • Preference optimization also tends to prefer the shorter, more direct trajectory, even if the longer trajectory has a higher success rate and better robustness.

    The result is a stable behavioral prior in the model: locate first, make minimal changes, verify immediately, and reuse existing information as much as possible. This prior is close to the optimal policy under a minimal toolset. Under a full toolset, however, two types of problems may appear:

    • Insufficient use of retrieval, dispatch, and planning tools that “look like detours”, and lack of confidence in “explore first, then act” strategies.
    • When tasks become complex enough to require divide-and-conquer, the model is not good at switching between multiple subgoals and maintaining state.

    The following pseudocode gives a simplified illustration of preference learning. Preference pairs are constructed from two successful trajectories for the same task, with the rule that the one with fewer steps wins. This is a common way to construct preference-optimization data.

    1. def build_preference_pairs(tasks, rollout, steps):
    2. # rollout: sample multiple successful trajectories for the same task (illustrative)
    3. dataset = []
    4. for task in tasks:
    5. for _ in range(4):
    6. traj_a, traj_b = rollout(task), rollout(task)
    7. winner = traj_a if steps(traj_a) < steps(traj_b) else traj_b
    8. loser = traj_b if winner is traj_a else traj_a
    9. dataset.append((task, winner, loser))
    10. return dataset # used for preference optimization
    11. policy = preference_optimize(base_policy, build_preference_pairs(tasks, rollout, steps))
    12. # Compare trajectories with no tools (minimal, k=3) and trajectories with multiple tools (k=15)
    13. report(evaluate_modes(tasks, [base_policy, policy]))

    Under this kind of preference signal, it is reasonable to expect that the preference-optimized policy will show a trend toward “more restrained tool calls and shorter chains”, and this tendency will be most fully reflected in a minimal toolset.

    Summary: minimal mode is not a model’s “memory region”; it is an amplifier of the model’s “policy preference”. Its constraints align with the preference reinforced during post-training, so it pushes that preference to the extreme.

    4. How to Judge Rigorously: Three Controlled Diagnostics

    For a specific model, more definite judgments can be made through variable isolation. At least three control experiments are recommended.

    4.1 Experiment A: prompt-equivalent rewriting

    • Method: keep the task set, toolset, weights, and decoding parameters unchanged. Only make equivalent rewrites of prompts, including paraphrasing task descriptions, adding context, changing field order, and changing format templates.
    • Interpretation: if scores fluctuate widely, the model likely depends on surface pattern matching, and prompt-level overfitting is possible. If scores are stable, the model likely understands the task semantically, and evidence for overfitting is insufficient.

    4.2 Experiment B: toolset ladder

    • Method: keep tasks unchanged and gradually expose tools, observing the performance curve.
      1. Minimal toolset, such as file editing + command line.
      2. Add retrieval tools.
      3. Add file batch operations and structured patch tools.
      4. Add sub-agent dispatch and task planning.
    • Interpretation:
      • If performance drops significantly when newly added tools are irrelevant to the current task and the model does not need them, this looks more like “amplified decision noise”.
      • If failure occurs only when a critical required tool is missing, this is a capability-boundary issue rather than overfitting.
      • If performance drops like a cliff as tool count increases, and the drop occurs when tool descriptions change rather than when task difficulty changes, this needs special investigation.

    4.3 Experiment C: tool semantic rewriting

    • Method: do not change tool functionality or parameter signatures; only rewrite tool names and descriptions, such as using clearer verb-based naming and adding “when to use / when not to use” guidance. Observe whether behavior remains stable.
    • Interpretation: if behavior changes little, the model is not bound to specific tool descriptions, and the hypothesis of “toolset overfitting” does not hold. If behavior changes significantly, the model is highly sensitive to tool descriptions, and correction should come from tool design rather than training.

    The three experiments can be combined into a judgment table:

    Experimental phenomenon More likely explanation Recommended response
    Scores fluctuate widely after equivalent prompt rewriting Suspected prompt-level overfitting Standardize prompt templates and add semantically equivalent rewrite samples
    Failure occurs only when critical tools are missing Capability boundary, not overfitting Evaluate real task requirements and add tools if necessary
    Performance drops when irrelevant tools are added Policy bias + decision noise Simplify toolsets, clarify tool usage boundaries, expose tools in stages
    Behavior changes significantly after tool-description rewriting High sensitivity to tool descriptions Improve tool-description standards and add usage guidance and examples

    5. Diagnostic Metrics: Making “Hesitation” Measurable

    “Models become more hesitant” is a subjective observation. In engineering, measurable metrics are needed. It is recommended to fix and collect the following metrics in evaluation frameworks:

    Metric Meaning Reference diagnostic signal
    Task success rate Whether the final goal is achieved Baseline of overall capability
    Average steps Number of actions needed to complete the task Clearly high step counts indicate decision redundancy
    Repeat-call rate Proportion of consecutive calls to the same tool with nearly identical parameters High values indicate idle loops
    Invalid-call rate Proportion of failed calls due to invalid parameters or nonexistent targets High values indicate insufficient tool understanding or state management
    Tool-hallucination rate Proportion of calls to unregistered tools or fabricated parameters High values indicate excessive toolset complexity or unclear descriptions
    Exploration-step ratio Proportion of retrieval/viewing actions among all steps Too high indicates insufficient “explore first, then act” strategy
    Plan drift Degree to which actual execution deviates from the initial plan High values indicate long-horizon goal drift
    First-attempt success rate Proportion of tasks solved on the first attempt Reflects policy stability

    The following is illustrative collection logic:

    1. def collect_trace_metrics(traces):
    2. agg = {
    3. "success_rate": 0, "avg_steps": 0.0, "repeat_rate": 0.0,
    4. "invalid_rate": 0.0, "hallucination_rate": 0.0,
    5. "explore_ratio": 0.0, "plan_drift": 0.0, "first_try_success": 0,
    6. }
    7. for trace in traces:
    8. actions = trace.actions
    9. n = max(len(actions), 1)
    10. agg["success_rate"] += int(trace.success)
    11. agg["avg_steps"] += len(actions)
    12. agg["repeat_rate"] += count_repeats(actions) / n # repeated probing
    13. agg["invalid_rate"] += count_invalid(actions) / n # failed calls
    14. agg["hallucination_rate"] += count_unknown_tools(actions) / n # unregistered tools
    15. agg["explore_ratio"] += count_explore(actions) / n # exploration actions
    16. agg["plan_drift"] += trace.plan_drift if trace.has_plan else 0.0
    17. agg["first_try_success"] += int(actions and actions[0].ok)
    18. total = max(len(traces), 1)
    19. return {k: round(v / total, 4) for k, v in agg.items()}

    These metrics can be used not only for offline comparisons between the two toolset modes, but also for continuous tracking through online observability systems such as logging and monitoring alerts. Sudden increases in repeat-call rate or invalid-call rate are often early signals that the policy is stuck in a specific environment.

    6. Engineering Recommendations: Making Models More Stable in Multi-Tool Environments

    Diagnostic conclusions ultimately need to translate into design. The following directions are directly actionable.

    6.1 Toolset design: few and orthogonal; descriptions as specifications

    • Single responsibility: one tool should do one thing, avoiding parameter bloat caused by “one tool doing ten things”.
    • Clear naming: use verb-based names, such as “search code”, “edit file”, and “run tests”, so the model can infer purpose from the name.
    • Structured descriptions: each tool should include “when to use, when not to use, parameter meaning, failure return”. Example template:
    1. Tool: Edit file
    2. Purpose: Perform a minimal text replacement in a single file
    3. Use when: the target file and target snippet are clearly identified
    4. Do not use when: changes need to be consistent across multiple files (use batch patch tools instead)
    5. Parameters:
    6. path target file path (must already exist)
    7. old original snippet to replace (must match uniquely)
    8. new replacement snippet
    9. Failure return: {"ok": false, "error": "old_not_unique", "candidates": 3}
    • Reduce functional overlap: tools with highly overlapping functions are a major source of “decision hesitation”. Merge them whenever possible.

    6.2 Progressive tool exposure: staged exposure instead of all at once

    Production environments do not have to choose between “minimal” and “full”. Tools can be made visible by task phase. Illustrative code:

    1. PHASE_TOOLS = {
    2. "explore": {"search_code", "read_file"}, # exploration: retrieval and reading only
    3. "implement": {"edit_file", "run_shell"}, # implementation: editing and execution only
    4. "verify": {"run_tests", "read_file"}, # verification: tests and reading only
    5. "finish": {"submit_result"}, # completion: submission only
    6. }
    7. def visible_tools(phase, current_task):
    8. names = set(PHASE_TOOLS[phase])
    9. if current_task.need_cross_repo: # add on demand, not all by default
    10. names |= {"search_repo", "dispatch_subtask"}
    11. return [REGISTRY[name] for name in names]

    For complex tasks, a lightweight router model can first route the task to a small set of candidate tools, then hand decision-making to the main model. This preserves the capability ceiling of multi-tool environments while keeping the action space within a decidable range.

    6.3 Runtime guardrails: budget, deduplication, loop detection

    The goal of guardrails is to turn “errors the model might make” into “errors the system can control”:

    • Step and time budgets: set a maximum number of steps for each task; when exceeded, stop and return intermediate results.
    • Duplicate detection: use an LRU cache keyed by “tool + parameter fingerprint”; if a duplicate call repeats consecutively, return the cached result or prompt “already attempted; try a different strategy”.
    • Loop detection: maintain action fingerprints for the recent $N$ steps; if a clear loop appears, force a switch to “summarize current state → propose a new hypothesis”.
    • Structured error returns: when a tool fails, return machine-readable error codes and repair suggestions rather than throwing the error back to the model for guessing.
    1. from collections import OrderedDict
    2. class Guard:
    3. def __init__(self, max_steps=40, repeat_window=16):
    4. self.max_steps = max_steps
    5. self.repeat_window = repeat_window
    6. self.seen = OrderedDict() # action fingerprint -> last call index
    7. self.history = []
    8. def before(self, step_idx, tool_name, args):
    9. if step_idx > self.max_steps:
    10. return {"decision": "stop", "reason": "step_budget_exceeded"}
    11. fp = fingerprint(tool_name, args)
    12. self.history.append(fp)
    13. recent = self.history[-self.repeat_window:]
    14. if fp in self.seen and len(set(recent)) <= max(2, len(recent) // 3):
    15. return {"decision": "block", "reason": "likely_loop", "last_error": self.seen[fp]}
    16. self.seen[fp] = last_error_of(tool_name, args)
    17. return {"decision": "allow"}
    18. def fingerprint(tool_name, args):
    19. return f"{tool_name}:" + hash_stable(sorted(args.items()))

    6.4 Model side: if training is available, prioritize correction over copying minimal mode

    • Curriculum reinforcement learning: first establish the main policy of “locate → modify → verify” in a low-tool environment, then gradually add tools and branches, teaching the model when to explore.
    • Contrastive preference data: construct preference pairs from “concise successful trajectories” and “verbose failed trajectories” for the same task, explicitly suppressing hesitation and divergence.
    • Process rewards: in addition to outcome rewards, apply negative rewards to “invalid calls”, “repeated calls”, and “plan drift”, making “make fewer mistakes” a learnable signal.
    • Data diversity: ensure that multi-tool, multi-branch, and sub-agent collaboration trajectories occupy a reasonable proportion in training data, avoiding a training distribution that itself favors a single tool chain.

    6.5 Evaluation side: unify methodology before drawing conclusions

    • Controlled comparison: when comparing configurations, keep weights, decoding parameters, task sets, timeouts, and step limits consistent, and change only one variable.
    • Multiple sampling: single results are insufficient. Run multiple times and report medians and quantiles.
    • Layered reporting: report “restricted-toolset results” and “full-toolset results” separately, with their environment configurations noted, to avoid using one directly to represent “model capability”.
    • Realistic task sets: in addition to general benchmarks, add real task sets that match your business distribution to prevent “high evaluation scores, poor online performance”.

    6.6 Operational governance: turning two modes into observable, regression-testable system capabilities

    • Include toolset configurations, prompt templates, and model versions in version control, and run the same diagnostic metrics on every change.
    • Enforce tool-call authentication, parameter validation, and quota control at the gateway layer.
    • Integrate the evaluation pipeline into continuous integration so that toolset or prompt changes trigger automatic regression, preventing “change one place, break many”.

    7. Conclusion and Outlook

    Returning to the original question:

    1. High scores under a minimal toolset result from a controlled environment releasing the model’s policy advantages. With fewer tools, shorter paths, and cleaner state, the model more easily enters a closed loop of “plan → modify → execute → verify”. This is a form of “constrained optimality” in design and cannot simply be equated with stronger general agent capability.
    2. One should not conclude overfitting without sufficient evidence. Post-training materials commonly cover multi-tool trajectories, and models have a basis for multi-tool decision making. A more evidence-compatible description is that “the linear tool-chain preference reinforced during post-training is amplified in minimal environments”, i.e., policy bias.
    3. Overfitting and policy bias can be distinguished. Through three controlled experiments—equivalent prompt rewriting, toolset ladder, and tool semantic rewriting—combined with diagnostic metrics such as repeat-call rate, invalid-call rate, and plan drift, one can largely locate whether the problem lies in training data, model policy, or tool design.
    4. The engineering solution is “constraint + progressive exposure + guardrails”, not a binary choice. Production environments do not have to choose between minimal and full. Exposing tools by phase, using structured tool descriptions to narrow the decision space, and using budgets and loop detection to cover tail risks can preserve the capability ceiling of multi-tool environments while avoiding amplified decision noise.

    For evaluators, judging whether an agent model is “truly strong” should be based on the performance it can reliably deliver in the target environment, not on peak performance on some restricted test bench. For builders, rather than obsessing over “whether it is overfitting”, it is better to focus on three things: tool design, runtime guardrails, and evaluation standards—these determine to what extent, and how stably, model capability can be converted into business outcomes.