OpenAI: GPT-5.5 (batch)

Review this 40-page technical specification for our new API gateway. Identify any inconsistencies in authentication flows, flag sections that contradict each other, and suggest where we need more detail before implementation.

In an illustrative response, the model would produce a structured analysis spanning the full document. It identifies three authentication flow inconsistencies: Section 2.4 describes OAuth2 token refresh as optional while Section 7.1 mandates it; the mTLS requirements in Section 5 conflict with the certificate rotation policy in Appendix C; and rate-limiting rules differ between the overview (Section 1.3) and the detailed spec (Section 9.2). The model flags eight areas needing expansion—particularly around error handling for partial failures and the undefined behavior when multiple auth methods are presented simultaneously. It cross-references related sections and provides specific page numbers for each issue.

The 1M+ token context window enables analysis of entire technical documents in one pass, eliminating the fragmentation that occurs when chunking long specs across multiple requests. However, at $15/Mtok output, a thorough 2,000-token analysis of this 40-page document costs approximately $0.03—negligible per-query but meaningful at scale for high-volume document review workflows.

I'm attaching our last 18 months of customer support tickets (JSON export, ~850K tokens). What are the top 5 unresolved product gaps that keep appearing, and which customer segments report each one most frequently?

In an illustrative response, the model would parse the entire ticket history and surface patterns invisible in smaller samples. It identifies five recurring gaps: enterprise customers repeatedly request granular permission inheritance (mentioned in 127 tickets, 71% from financial services); mobile users report sync conflicts during offline-to-online transitions (89 tickets, concentrated in field service accounts); API users need webhook retry configuration beyond the current 3-attempt limit (64 tickets, primarily SaaS integrators); the search function fails on non-Latin scripts (43 tickets, all from APAC markets); and bulk operations lack progress indicators for datasets over 50K records (38 tickets, data analytics segment). The model groups tickets by customer tier, industry vertical, and temporal clustering to show which gaps are growing.

Processing 850K tokens of structured data in a single context allows the model to detect cross-ticket patterns and segment-specific pain points that sampling or RAG retrieval would miss. The batch API's lower pricing ($2.50 input vs. real-time tiers) makes this 18-month retrospective cost-effective, though the asynchronous nature means it suits scheduled analysis rather than live support triage.

Here's a 200-page codebase for our inventory management system (Python, includes tests and configs). Walk me through the critical path for order fulfillment, explain how the reservation locking works, and identify any race conditions in the current implementation.

In an illustrative response, the model would trace the fulfillment flow across 14 files, starting from the API endpoint in `orders/views.py` through the inventory check in `warehouse/availability.py` to the final commit in `transactions/ledger.py`. It explains that reservation locking uses PostgreSQL advisory locks (see `db/locks.py` lines 45-67) with a 30-second timeout, but identifies a race condition in `warehouse/allocation.py` lines 112-128 where the lock is released before the audit log write completes—if two requests target the last unit simultaneously, both can succeed in the 40ms window between lock release and log persistence. The model maps the sequence diagram, highlights the three external service calls that extend the critical path, and notes that the retry logic in `orders/retry_handler.py` doesn't account for this specific failure mode.

The extended context window allows the model to hold an entire mid-sized codebase in memory, enabling whole-system reasoning about control flow and state management that's difficult when working file-by-file. The model can trace dependencies across modules without losing context. Trade-off: at 200 pages (~500K tokens input), the analysis costs roughly $1.25 in input tokens alone—reasonable for architecture reviews but expensive for routine code questions.

When 1M+ token context justifies the $15/Mtok output premium

A 4-person corporate dev team closing 2-3 acquisitions per quarter needs to cross-reference 40+ contracts, financial statements, and IP filings in a single pass. GPT-5.5 batch handles the entire diligence packet—850k tokens of scanned PDFs and spreadsheets—without chunking or retrieval hacks. The $2.50 input rate makes the load cheap; the $15 output cost only hits when you generate the 12k-token summary memo. Run the job overnight in batch mode and pull a unified risk matrix by morning. If your deals are under 300k tokens or you need answers in under 10 minutes, use the real-time tier or a cheaper long-context model. For quarterly closings with document sets this large, the context window and batch discount make this the cleanest play.

Batch-processing entire repos when speed isn't the constraint

A 9-engineer SaaS team wants to migrate 120k lines of Python to async patterns before the next funding round. They dump the full monorepo—480k tokens—into GPT-5.5 batch with a prompt that maps every blocking I/O call and suggests refactor sequences. The job runs for 6 hours and returns a 25k-token migration plan with file-level diffs and dependency graphs. The $15/Mtok output rate adds $375 to the sprint budget, but the alternative is three engineers spending a week on manual analysis. If you need the plan in under an hour or your repo is under 100k tokens, use a real-time model with lower latency. For once-a-quarter architecture rewrites where overnight turnaround works, this is the right trade-off.

When you process 500+ employee records once a year

A 12-person HR consultancy audits client handbooks, training transcripts, and incident logs against evolving labor regulations. They batch-process 600 employee files—720k tokens—through GPT-5.5 to flag policy gaps and generate remediation checklists. The job runs overnight; the $2.50 input rate keeps the per-employee cost under $3, and the $15 output rate is acceptable because they only generate 8k tokens of findings per client. If you're running these audits monthly or need same-day results, the batch latency kills you—switch to a real-time model or a cheaper provider. For annual compliance sweeps where you can queue the work and wait, the context window and batch pricing make this the most economical long-context option.