OpenAI: GPT-5 Nano

Review this Python function for edge cases and suggest improvements. Focus on input validation and error handling that might break in production.

This function lacks validation for empty iterables and doesn't handle non-numeric types gracefully. The division operation will raise ZeroDivisionError when the list is empty. Add a guard clause checking `if not values: raise ValueError("Cannot compute mean of empty sequence")` at the start. Consider using `isinstance()` checks or try-except blocks for type safety. The current implementation also fails silently with None values—either filter them explicitly or document that behavior. For production use, add logging around the exception paths and consider returning a Result type instead of raising.

GPT-5 Nano's 400K context window allows it to analyze entire codebases for systemic patterns, but this example shows its strength in focused code review. The response identifies three distinct failure modes and provides actionable fixes. At $0.40/Mtok output, longer refactoring sessions cost more than competing models with similar capabilities.

Analyze this customer support transcript and extract: sentiment, main issue, whether it was resolved, and any product feedback. Format as structured JSON.

Based on the transcript, the model would produce: `{"sentiment": "frustrated → satisfied", "main_issue": "billing_error_double_charge", "resolved": true, "resolution_time_minutes": 12, "product_feedback": ["unclear refund timeline in UI", "wants email confirmation for disputes"], "agent_performance": "effective—acknowledged frustration early, explained process clearly"}`. The JSON structure captures both explicit statements and implied context, like the sentiment shift after the agent's explanation. It correctly identifies the UI clarity issue even though the customer didn't use those exact words.

This showcases GPT-5 Nano's multimodal file handling—it can process uploaded transcripts, chat logs, or support tickets directly. The inference quality is strong for business document analysis. However, the $0.05 input pricing means batch processing thousands of tickets daily becomes expensive compared to specialized classification models.

I'm attaching a photo of a handwritten recipe card from my grandmother. Transcribe it, convert measurements to metric, and suggest modern substitutions for any outdated ingredients.

The model would process the image and return: "**Grandma's Molasses Cookies** // Original: 1 cup shortening → 225g butter or neutral oil // 1 cup molasses (keep as-is, or use 200g dark treacle) // 2 eggs → 2 large eggs (100g) // 3 cups flour → 375g all-purpose flour // [continues with full transcription] // **Modern substitutions:** Replace shortening with European-style butter for richer flavor, or use refined coconut oil for dairy-free. The recipe calls for 'sour milk'—use 240ml buttermilk or add 1 tbsp lemon juice to regular milk. Baking soda amount (2 tsp) is correct for the molasses acidity."

Image understanding combined with domain knowledge (baking chemistry, ingredient evolution) demonstrates GPT-5 Nano's multimodal reasoning. The 400K context means it could process an entire handwritten cookbook in one request. Trade-off: no public benchmarks yet, so vision performance relative to GPT-4o or Claude 3.5 Sonnet remains unverified in production scenarios.

Why GPT-5 Nano handles 500+ daily tickets without breaking budget

A 12-person SaaS company routing 500-800 support tickets daily needs fast classification and draft responses without the per-token cost of frontier models. GPT-5 Nano delivers at $0.05 input / $0.40 output per Mtok—roughly 8x cheaper than GPT-4o on input and 3x cheaper on output. The 400k context window means you can dump entire ticket histories, past resolutions, and knowledge base articles into a single prompt without chunking. At this volume, you're processing maybe 15-20M tokens daily; Nano keeps that under $10/day where GPT-4o would run $60-80. The trade-off: no public benchmarks yet, so you'll want to A/B test classification accuracy against your current model for two weeks before full rollover. If accuracy holds within 2-3 points of your baseline, the cost savings fund another support hire.

When 400k context beats RAG for legal teams under 10 people

A 6-attorney firm reviewing vendor contracts (20-40 pages each, plus exhibits) traditionally chunks documents into a RAG pipeline or pays for Claude Opus at $15 input / $75 output per Mtok. GPT-5 Nano's 400k window fits 3-4 full contracts plus a 10-page checklist in one prompt—no retrieval layer, no embedding costs, no context-loss from chunking. At $0.05 input, a 150k-token prompt (roughly 3 contracts) costs $0.0075; the same workload on Opus is $2.25. For firms processing 50-100 contracts monthly, that's $400-800 in savings. The risk: without MMLU-Pro or GPQA scores, you don't know if Nano matches Opus on clause extraction accuracy. Run 10 contracts side-by-side, score precision on non-compete and indemnity clauses, and if Nano hits 95%+ agreement, make the switch.

How Nano turns 90-minute calls into structured Notion pages for $0.12

A 15-person agency records client calls (60-90 minutes, ~40k tokens transcribed) and needs action items, decisions, and follow-ups extracted into Notion within 5 minutes of the call ending. GPT-5 Nano processes a 40k-token transcript for $0.002 input, generates a 2k-token structured summary for $0.0008 output—total cost $0.003 per call. At 40 calls/month, that's $0.12 versus $4.80 on GPT-4o. The 400k context means you can include the last 3 calls with this client for continuity without prompt engineering tricks. The caveat: image and file modalities suggest Nano can handle slide decks shared during calls, but latency matters here—if Nano's time-to-first-token is over 3 seconds, users will feel the lag. Test 5 calls end-to-end; if summaries land in Notion under 20 seconds and capture 90%+ of action items compared to manual notes, deploy it.