GPT-5.4 mini/nano Subagent Architecture Guide: Which Tasks Go to Flagship, mini, and nano

Have you ever looked at your end-of-month OpenAI bill and found that most of the cost came from repetitive subtasks — code search, document classification, structured data extraction? We ran into the same problem in our own AI agent system. The real issue wasn't "is mini/nano good enough?" — it was that we'd never stopped to ask which tasks didn't need a flagship model in the first place.

This guide uses the Planner-Executor-Reviewer framework to give you a task assignment decision table you can apply immediately. Based on our hands-on experience testing mini against individual subtasks in a real content pipeline, here are the actual results and recommendations.

TL;DR

• GPT-5.4 mini/nano are not cheap flagship models — OpenAI explicitly designed them for specific roles in a multi-model agent architecture
• Planner-Executor-Reviewer three-layer architecture: flagship plans, mini executes, nano classifies — saves ~70% in API costs
• mini's coding benchmark trails the flagship by only 3% (per OpenAI), but accuracy drops from 79.3% to 33.6% on 128K+ context tasks (Simon Willison's personal testing)
• nano's 3.1% hallucination rate in grounded summarization tests is actually lower than some flagship models (Vectara HHEM-2.3 independent test) — but this only applies to structured extraction, not general accuracy
• The most practical strategy: don't "switch everything to nano" — instead, use mini/nano for new repetitive subtasks while leaving existing workflows untouched

GPT-5.4 mini/nano Are Not "Cheaper Flagships" — They're Designed for Different Roles

Most people's first reaction to mini/nano is "a discounted GPT-5.4." But if you read OpenAI's official launch documentation, the positioning is entirely different.

When OpenAI released GPT-5.4 mini and nano on March 17, 2026, they explicitly defined the roles: nano is suited for "classification, data extraction, ranking, and coding subagents for simpler supporting tasks"; mini is suited for "systems that combine models of different sizes, where GPT-5.4 handles planning while mini subagents handle narrower subtasks in parallel." The New Stack's coverage headline says it directly: "GPT-5.4 mini and nano are built for the subagent era."

Here's a counterintuitive fact: in Vectara's HHEM-2.3 grounded summarization benchmark, nano has a hallucination rate of just 3.1% — lower than GPT-5.4-pro. The reason is that nano is trained to respond conservatively: when uncertain, it doesn't generate rather than producing a plausible-sounding fabrication.

Important: This 3.1% hallucination rate comes from Vectara's grounded summarization test (reported by usewire.io), which specifically measures a model's faithfulness to source material — not general accuracy. On open-ended Q&A or complex reasoning tasks, nano still falls noticeably short of flagship models. This is precisely why nano fits classification and extraction, not planning or judgment.

So the right question isn't "how much worse is mini/nano than GPT-5.4?" It's "in my agent system, which subtasks have characteristics that match nano's strengths — structured, short context, high repetition?"

Planner-Executor-Reviewer Three-Layer Architecture: The Design Logic Behind 70%+ Cost Savings

Once you understand mini/nano's positioning, the next question is "how do I actually use them?" The answer is the Planner-Executor-Reviewer three-layer architecture — not a framework we invented, but the actual usage pattern OpenAI described when launching mini/nano.

The architecture logic is intuitive:

Planner (Flagship: GPT-5.4 / Claude Opus)
  → Analyzes task requirements, forms a plan, makes final judgments
  → Handles complex reasoning and decisions requiring global understanding

Executor (GPT-5.4 mini)
  → Executes subtasks assigned by Planner: code search, document processing, parallel task runs
  → Ideal for the execution layer where speed and cost efficiency matter

Reviewer / Classifier (GPT-5.4 nano)
  → Fast classification, data extraction, structured output
  → Ideal for high-volume repetitive quality verification steps

The Neuron Daily used a precise analogy: the flagship model is the senior manager, mini/nano are interns handling repetitive tasks. You wouldn't ask a senior manager to classify 500 data records, just as you wouldn't ask an intern to handle strategic planning.

Based on our actual testing in a content pipeline, switching classification and data extraction steps from flagship models to mini/nano reduced API costs for those subtasks by about 70%, with virtually no quality difference on structured tasks. The key is the multiplication effect of task volume and per-call cost — in most agent systems, 70-80% of API calls are repetitive subtasks, and those are what actually drive spend.

Gartner predicts (note: this is a forecast, not realized data) that roughly 60% of enterprise AI deployments in Q4 2026 will use multi-model architectures. Whether or not that exact figure holds, the underlying logic is straightforward: using one model for everything is like using one knife for all ingredients — it works, but it's not smart.

Task Assignment Decision Table: One Table to Pick Your Model

This is the most important part of the article. Based on OpenAI's official documentation and our own testing, here are the recommended models for each task type:

Task Type	Recommended Model	Reason
Strategic planning, final judgment	Flagship (GPT-5.4 / Opus)	Requires complex reasoning; high cost of errors
Code search, document processing (<100K tokens)	mini	Coding gap is only 3% (per OpenAI); best cost-efficiency
Parallel subtask batch execution	mini	2x speed, ~70% lower cost
Large-scale document classification / tagging	nano	Low hallucination rate suits structured output
Data extraction (<50K tokens)	nano	Lowest cost at high volume
Ranking, filtering	nano	Explicitly designed use case per OpenAI
Complex multi-step reasoning	Flagship	FrontierMath: mini 9.6% vs GPT-5.4 26.3%
Long document analysis (>100K tokens)	Flagship	mini accuracy degrades sharply at 128K+ (see next section)
Creative writing, nuanced judgment	Flagship	mini/nano not suited for tasks requiring deep contextual understanding

If your existing agent system uses flagship models throughout, you don't need to rewrite anything. Switching models requires changing a single parameter: model="gpt-5.4" to model="gpt-5.4-mini". The API format, function calling interface, and system prompt conventions are all identical.

If your agent tasks mainly involve "take a large block of text and extract structured information" — if the input is under 50K tokens, nano handles it well; 50K–100K, mini is safer; over 100K, let the flagship handle it.

The Long-Context Trap: Keep 128K+ Token Tasks Away from mini/nano

This is the most commonly misused scenario with mini/nano, and the one where most people get burned.

GPT-5.4 mini is listed with a 400K context window. But "can fit 400K tokens" and "can effectively process 400K tokens" are two different things. Simon Willison's personal testing documented a key finding: mini's accuracy on MRCR v2 (a benchmark measuring long-text comprehension) in the 128K–256K context range drops from GPT-5.4's 79.3% to just 33.6%.

Important: This degradation data comes from Simon Willison's personal testing, not OpenAI's official benchmarks. But it aligns with practical experience: effective context is typically 60–70% of the listed maximum.

What does this mean in practice?

• Feeding a complete codebase (typically over 100K tokens) to mini for analysis → results will be poor
• Large RAG pipelines stuffing entire documents into mini for summarization → high risk of content omission
• Long conversation history accumulating past 128K → response quality starts noticeably declining

The fix isn't "don't use mini" — it's correct task splitting:

1. Chunking strategy: Break long documents into <30K token chunks, use nano to process them in batches, then let the flagship model integrate the results
2. Smart routing: Have the agent system check input length and automatically route tasks >100K tokens to the flagship
3. Hierarchical processing: nano does first-pass classification ("which topic does this document relate to?"), then hands relevant chunks to mini for detailed processing

Real Cost Calculations: Honest Numbers Including Retry Costs

Here are the official pricing figures for each model (verified April 2026):

Model	Input / 1M tokens	Output / 1M tokens	vs GPT-5.4
GPT-5.4	$2.50	$15.00	Baseline
GPT-5.4 mini	$0.75	$4.50	~70% cheaper
GPT-5.4 nano	$0.20	$1.25	~92% cheaper
Claude Sonnet 4.6	$3.00	$15.00	Slightly more than GPT-5.4

Note: nano is API-only — it's not available in the ChatGPT interface. mini is also available on ChatGPT's Free tier.

Three real-world scenarios:

Scenario 1: Large-scale image caption generation Simon Willison used nano to generate captions for 76,000 images at a total cost of $52. The same task with GPT-5.4 would have cost approximately $650.

Scenario 2: Coding agent (4K input + 2K output per call)

• GPT-5.4: ~$0.04 per call ($2.50 × 4K/1M + $15.00 × 2K/1M)
• mini: ~$0.012 per call ($0.75 × 4K/1M + $4.50 × 2K/1M)
• At 500 calls/day (moderate agent usage), the monthly difference is about $420

Scenario 3: Small creator with 100 conversations per day Nano saves roughly $30–50/month vs GPT-5.4. Not huge on its own, but if you're running multiple small tools, it adds up.

Honest retry cost adjustment: The calculations above assume ideal conditions. In practice, nano has a 10–15% retry rate on edge cases (like slightly complex classifications). Factoring in retries, the actual savings are roughly 20% lower — dropping from an ideal 70%+ to a realized 55–60%. Even with that discount, mini's retry costs are still far below what you'd pay for a flagship model succeeding on the first attempt.

The Blended Approach: Why Most Developers "Add On" Rather Than Replace

If your current agent system runs entirely on Claude Sonnet 4.6 or GPT-5.4, should you switch everything to mini?

Short answer: no.

According to a developer survey by findskill.ai, most practitioners don't replace — they add on. They assign new repetitive subtasks to mini/nano while leaving existing workflows in place. Three reasons:

1. Different tools have different strengths: Claude Sonnet still has advantages in complex reasoning and long-form writing. Switching everything to mini means giving up those strengths
2. Migration costs are underestimated: Re-tuning prompts, rewriting system architecture, testing quality deltas — the time cost usually exceeds the short-term API savings
3. Avoid vendor lock-in: If your entire system depends on a single model, you have no fallback when that model raises prices or degrades. A mixed approach makes the system more resilient

If you're managing both Claude SDK and OpenAI SDK simultaneously, debugging complexity does increase. Our recommendation is to start by testing mini/nano on a single new agent subtask, confirm the quality meets your requirements, then expand — don't migrate an entire system at once.

Best starting points for mini/nano:

• New classification agents (document classification, tag generation)
• New data extraction pipelines (extracting structured data from unstructured documents)
• Quality verification steps (checking whether output format is correct)

If you want a fuller comparison of AI API pricing and use cases across providers, check out our AI API Cost Comparison Guide.

OpenAI Agents SDK Implementation: Switch with a Single model Parameter

The technical implementation is actually very simple. mini and nano use the exact same API format as GPT-5.4 — switching requires changing just one parameter.

Here's sample code for building the Planner-Executor-Reviewer architecture using the OpenAI Agents SDK:

from agents import Agent, Runner

# Planner (flagship model — handles overall planning)
planner = Agent(
    name="Planner",
    model="gpt-5.4",
    instructions="Analyze the user's task requirements, break them down into specific subtasks, and assign them to the appropriate Executor or Reviewer."
)

# Executor (mini — handles specific subtask execution)
executor = Agent(
    name="Executor",
    model="gpt-5.4-mini",  # Change only this line
    instructions="Following Planner's instructions, execute specific tasks such as search, document processing, or code generation."
)

# Reviewer (nano — handles classification and validation)
reviewer = Agent(
    name="Reviewer",
    model="gpt-5.4-nano",  # Change only this line
    instructions="Validate the format of Executor's output, apply classification labels, and filter for quality."
)

Note: The code above reflects the OpenAI Agents SDK's Agent constructor pattern. The model parameter accepts a model name string directly. Use the dateless model ID (e.g. gpt-5.4-mini rather than gpt-5.4-mini-2026-03-17) to automatically follow OpenAI's version updates and avoid locking to a specific snapshot.

If you're not a developer, mini is also available directly in ChatGPT's Free tier. nano is API-only, but non-engineers can call it through n8n's HTTP Request node or Make/Zapier's OpenAI integration — these no-code tools all support specifying the model parameter.

Azure AI Foundry has also integrated mini and nano, so enterprise users can use them within the same Azure environment without additional API setup.

Limitations and Risk Disclosure

To be honest, mini/nano aren't a universal solution. Here are the limitations you need to know before adopting them:

nano access restrictions: nano is API-only and not available in the ChatGPT Free/Plus/Pro interface. This means non-engineer team members who need to use nano must do so through an API wrapper or no-code tool (such as n8n or Make).

Hallucination rate scope: The 3.1% hallucination rate mentioned earlier (Vectara HHEM-2.3) applies specifically to grounded summarization tasks. For open-ended Q&A, complex reasoning, or creative tasks, nano's output quality is noticeably worse than flagship models. Don't see "3.1%" and assume nano is reliable across the board.

Significant gap in complex reasoning: On the FrontierMath benchmark, mini scored 9.6% vs GPT-5.4's 26.3% — nearly a 3x gap. For multi-step reasoning, mathematical computation, or tasks requiring global understanding, use the flagship.

Version update risk: OpenAI releases new versions roughly every 3–6 months (GPT-5.0 → 5.1 → 5.2 → 5.4). The API format is currently compatible, but long-term maintenance isn't guaranteed. Monitor OpenAI's deprecation notices, and design your agent system with an abstraction layer that makes models swappable — so changing models only requires updating a config file, not rewriting logic.

Retry costs are not negligible: nano requires retries on edge-case classification tasks. High-quality agent systems should implement a fallback mechanism — automatically escalate from nano to mini on failure, and from mini to flagship on failure.

Conclusion: mini/nano's Value Isn't Being Cheap — It's Letting Flagships Do Flagship Work

If you take one concept from this article, let it be this: mini/nano's core value isn't "cheap" — it's specialization. They transform your flagship model from "a full-time employee who does everything" into "a senior manager who only handles high-value decisions."

Five steps you can execute right now:

1. List every subtask in your agent system — categorize each API call as "planning," "execution," or "validation"
2. Cross-reference the decision table above — mark which tasks can safely switch to mini (execution) or nano (validation)
3. Pick one low-risk task to test first — we recommend starting with data extraction or classification tagging, which is nano's strongest use case
4. Compare quality in OpenAI Playground or your test environment — run 50–100 real data samples and confirm the output quality is acceptable
5. Change one model parameter and ship — that's it, no architecture changes needed

If you want to go deeper on combining different models in an agent system, we've also written an AI Agent Memory Architecture Guide that covers state management and memory design in multi-agent systems.