OpenAI: GPT-6 Astra Pro

Review this 40-page technical specification for our new API gateway. Identify any security gaps, inconsistent naming conventions, and sections that contradict each other across the document.

In this illustrative example, the model would produce a structured analysis spanning the full 40-page specification. It would flag three security concerns: missing rate-limit definitions in Section 7, OAuth scope inheritance ambiguity in Section 12, and unencrypted logging of tokens mentioned in Section 23. It would identify seven naming inconsistencies (alternating between camelCase and snake_case for similar parameters). The model would highlight two direct contradictions: Section 9 states webhook retries max at 5 attempts while Section 18 references a 3-attempt limit, and timeout values differ between the overview and implementation sections.

The 1.05M token context window enables analysis of entire technical documents in one pass, eliminating the need to chunk or summarize. This example demonstrates cross-referencing capability across distant sections. However, at $50/Mtok output pricing, a thorough review generating 5,000 tokens costs $0.25 — teams doing frequent document reviews should budget accordingly.

I'm debugging a memory leak in our Python service. Here's the full codebase (87 files, ~45K lines). The leak appears after 6 hours of runtime. Walk me through likely causes and which files to investigate first.

In this illustrative example, the model would ingest the entire codebase and produce a prioritized investigation plan. It would identify that three files show circular reference patterns in their class definitions, two background worker threads lack proper cleanup in their exception handlers, and one database connection pool in `db/pool.py` doesn't explicitly close connections on timeout. The model would note that `services/cache.py` accumulates references in a module-level dictionary without eviction logic, and that the metrics collector in `monitoring/stats.py` appends to an unbounded list. It would recommend starting with the cache service, providing specific line numbers and suggesting a fix using `weakref`.

Multi-file reasoning across 45K lines showcases the extended context advantage — the model can trace object lifecycles across module boundaries without losing thread. The file-upload modality means you can drag in a repository export directly. Trade-off: the $10/Mtok input cost means analyzing this codebase (~180K tokens) costs ~$1.80 per query.

Translate this 28-page legal contract from English to German, maintaining all clause numbering, defined terms in caps, and the formal register required for German corporate law. Flag any terms that don't have direct legal equivalents.

In this illustrative example, the model would produce a complete German translation preserving the document's structure: all section numbers, subsection labels, and cross-references would remain intact. Defined terms like "EFFECTIVE DATE" would become "WIRKSAMKEITSDATUM" and maintain consistent capitalization throughout. The register would shift appropriately to German legal formality (using "vertragsschließende Parteien" rather than casual equivalents). The model would append a glossary noting that "promissory estoppel" lacks a single German equivalent and was rendered as "Vertrauenshaftung," with a footnote explaining the doctrinal difference. Similarly, "punitive damages" would be flagged as a concept absent from German civil law.

Long-form translation with structural preservation demonstrates both the context capacity and multi-modal understanding (processing formatted legal documents). The model maintains consistency of legal terminology across 28 pages without drift. However, legal translation still requires human review — the model correctly flags ambiguous terms but cannot substitute for jurisdiction-specific legal expertise.

Why Astra Pro handles 200-file deal rooms without summarization hacks

A 4-person corp dev team closing 8 deals/year needs to cross-reference term sheets, financials, IP assignments, and employment contracts across 150–300 documents per transaction. Astra Pro's 1M+ token window means you load the entire data room into a single thread and ask cross-file questions without chunking or retrieval engineering. At $10/Mtok input, a 600k-token deal room costs $6 to ingest once, then you query it 40–60 times over two weeks at $50/Mtok output (roughly $15–25/deal in generation). The math works if you're closing deals worth six figures and your alternative is 12 hours of associate time per diligence cycle. Below 4 deals/year, the context window is overkill and you're better off with a cheaper model plus basic RAG.

When Astra Pro's output cost kills the unit economics on support triage

A 30-person SaaS company fields 800 inbound chats/day and wants an LLM to classify intent, extract account details, and route to the right specialist. Astra Pro can do this accurately, but at $50/Mtok output and an average 120-token response per chat, you're spending $4.80/day ($1,750/year) just on generation. Input is negligible (chat messages are short), but the output volume makes this expensive compared to a $2/Mtok model that would cost $350/year for the same workload. The giant context window buys you nothing here—chat routing doesn't need long memory. Use Astra Pro only if you're also embedding multi-page account histories into every routing decision and the accuracy delta justifies 5× the cost. Otherwise, route to a cheaper classifier.

Astra Pro for low-frequency, high-stakes narrative synthesis

A 10-person startup prepares a 40-slide board deck every quarter by synthesizing metrics dashboards, customer feedback transcripts, roadmap docs, and competitive intel—total input around 400k tokens. The CEO needs a model that can hold all the context, write coherent narrative arcs across sections, and reference specific data points without hallucinating. Astra Pro's context window handles the full corpus in one pass, and at 4 decks/year the cost is manageable: $4/deck input, maybe $20–30/deck output if you generate 15–20k tokens of draft prose. The $100–140/year total is a rounding error compared to 8 hours of founder time per deck. The trade-off: if you're generating decks monthly or need real-time collaboration, the output cost scales poorly and you should pre-filter inputs or use a cheaper model for iteration.