AI Tech Inspire

Why Project Folders Force GPT-5 Thinking Mini Over Your Default Model

If your workflow depends on consistent model behavior, few things are more jarring than seeing your “Auto” setting quietly resolve to a smaller model when you enter a different workspace. That’s exactly what some users are reporting with Project Folders: inside a project, the system keeps identifying itself as GPT-5 Thinking Mini even when the global picker is set to use GPT-5 via Auto. Outside projects? Everything’s fine. Inside? It’s Mini, every time.

What’s being reported

  • Inside Project Folders, the AI consistently identifies as GPT-5 Thinking Mini despite the model picker being set to Auto under GPT-5.
  • Outside Project Folders, Auto resolves to GPT-5 and functions as expected.
  • Across multiple folders, Auto resolves to Mini without any user-initiated switch.
  • The user does not intentionally select Mini; it appears locked when working inside projects.
  • Other users have asked about model defaults in Projects, but no official communication has been seen.
  • Open questions: Are projects hard-wired to Mini? If so, why wasn’t this communicated and will it change? If not, is this a model-assignment bug?
  • Impact: Projects include critical work (school assignments, job applications, business content, custom GPT builds) that require full GPT-5 capability; Mini is perceived as insufficient.

Why this matters

Developers, engineers, and AI builders rely on predictable capability, latency, and cost profiles from their models. When a workspace silently forces a smaller model, it affects:

  • Capability: Larger models typically handle complex reasoning, long-context synthesis, and nuanced instructions better. A surprise downgrade can reduce output quality or break prompts tuned for a stronger model.
  • Determinism and reproducibility: Teams need consistent runs for audits, QA, or compliance. If “Auto” maps differently between contexts, test results drift.
  • Latency vs. accuracy trade-offs: A Mini tier often trades capability for speed and cost. That can be great for bulk tasks, but harmful for precision work (e.g., research, legal memos, or advanced coding assistants).
  • Trust and transparency: Users deserve clarity on which model is active, especially when a setting promises “Auto under GPT-5” and then behaves differently in a project context.

Key takeaway: If your prompt design assumes GPT-5-level reasoning, an invisible switch to a Mini-tier can quietly degrade your results without obvious errors.

What could be happening under the hood

There are a few plausible explanations that don’t require malice or misconfiguration on the user’s part:

  • Workspace-level routing: “Auto” often means a dynamic router that picks a model given context + constraints. Inside a Project Folder, a different routing policy could be active—perhaps tuned for cost or latency.
  • Project defaults: Some systems let admins or templates pin a default model per project. If a project template or hidden setting enforces Mini, the UI picker might still say Auto—but the resolver maps to Mini in that context.
  • Token budget or memory limits: Long-running projects with large file attachments, custom instructions, or extended conversation history sometimes push systems to select less expensive models to stay within budget or rate-limits.
  • Feature flags or staged rollouts: It’s possible a routing change is being tested in Project Folders only, affecting “Auto” behind the scenes.

At AI Tech Inspire, the pattern reported here is notable: outside projects, Auto = GPT-5; inside projects, Auto = Mini, consistently across multiple folders. That points to a scoped routing policy—or a bug that treats Project Folders differently.

First checks and practical workarounds

Until there’s an official answer, here are pragmatic steps developers can take to regain control:

  • Manually select a specific model inside the project instead of relying on Auto. If the UI allows direct selection (e.g., explicitly picking GPT-5 rather than Auto under GPT-5), try that and confirm the model identity.
  • Inspect project-level settings. Look for any “default model,” “optimize for cost/latency,” or “economy mode” toggles. If a project template was used, check its defaults, too.
  • Start from a clean project. Create a new Project Folder with no files or long history. Set the model explicitly. If it still resolves to Mini, the behavior is likely systemic.
  • Temporarily work outside Projects for critical tasks that require GPT-5-level reasoning, then archive results into the project after completion.
  • Browser-level sanity checks: Sign out and back in, clear cache, and disable browser extensions that might inject content or alter UI scripts.
  • Ask for the resolved model each run—but verify thoughtfully. Model self-identification in text is not foolproof. Cross-check using capability tests (e.g., complex chain-of-thought tasks) rather than relying solely on a string the model prints about itself.

If you’re using an API in parallel, you can guarantee the model with explicit IDs. Example skeletons:

// Pseudocode: force a specific model
client.chat.completions.create({
  model: "gpt-5", // vs "gpt-5-mini"
  messages: [...],
});

// Or in Python-like pseudocode
resp = client.chat.completions.create(
  model="gpt-5",
  messages=[{"role": "user", "content": "..."}],
)

In UI-only workflows, explicit selection is your best bet. If that’s not honored in a Project Folder, it strengthens the case for a routing bug or a forced default.

How to verify the actual model

Textual self-reporting can be unreliable. Consider:

  • Capability probes: Ask the same complex, multi-step prompt both inside and outside a project. Evaluate outputs for reasoning depth, error rates, and adherence to instructions.
  • Structured tasks: Try deterministic, high-signal prompts like multi-table joins in SQL, multi-file code refactors, or math proofs. Larger models tend to handle these more robustly.
  • If you have API access: Log the model field and compare. UI and API may differ, but API logs can help isolate whether the issue is UI-only or systemic.

Remember: A model saying “I am X” is not proof. Treat self-identification like any other generated text—use external signals to verify.

Context from the broader ecosystem

Model routing and “Auto” settings are increasingly common. GitHub Copilot and IDE assistants sometimes switch between lightweight and larger backends for speed versus capability. Anthropic’s workspace features and Google’s Gemini-based tools also balance routing, context windows, and cost in the background. The same trade-offs appear across ML stacks that developers know well, whether coding with PyTorch or TensorFlow, or deploying models via Hugging Face with inference endpoints that vary by tier.

For general model families like GPT, “Auto” can be great—until it isn’t. When the cost/latency router flips your model without explicit consent, it can be a productivity tax. The fix isn’t necessarily to abandon routing; it’s to give users visibility and overrides that respect intent, especially in contexts named “Projects” where expectations around persistence and control are higher.

What a clear vendor response would include

  • Transparent model labeling in UI: Always show the resolved model ID, not just “Auto”. Bonus: a one-click way to lock the current selection.
  • Project-level defaults panel: A visible setting indicating which model the project enforces, with the ability to opt out.
  • Routing rationale: If Auto resolves to Mini, explain why (cost limits, token budgets, performance tiers) and how to change it.
  • Change logs and comms: If this is a temporary safeguard or an A/B test, communicate timelines and workarounds.
  • Bug triage path: Clear instructions for reporting, including steps to reproduce, timestamps, and conversation IDs/screenshots.

Action plan for teams today

  • Codify model expectations in your project readme: which tasks require full GPT-5, which are safe on Mini, and how to switch.
  • Create a smoke-test prompt suite (think unit tests for model capability) to detect silent downgrades.
  • Document UI anomalies with screenshots and short repro steps. If this is a bug, precise reports accelerate fixes.
  • Segregate critical workflows into environments where the model can be explicitly set and verified (API, dedicated workspace, or project with a known-good template).

Bottom line

Based on the reports, Project Folders appear to route Auto to GPT-5 Thinking Mini, even when the global picker suggests GPT-5. Whether that’s a deliberate policy, a template default, or a bug, the impact is the same: critical work risks being handled by a less capable model without clear notice.

For now, the safest path is to bypass Auto in projects—explicitly select the desired model, verify with capability tests, and keep a minimal, reproducible setup for tasks that truly need GPT-5-level reasoning. And if you’re seeing this behavior, raise it through official channels. At AI Tech Inspire, we’ll keep tracking this pattern and update readers when there’s an authoritative explanation or a confirmed fix.

Recommended Resources

As an Amazon Associate, I earn from qualifying purchases.