OpenAI: GPT-6 Astra

Review this 40-page technical spec for our new API gateway. Identify architectural risks, suggest three concrete improvements, and flag any sections that contradict our existing auth patterns.

In this illustrative example, the model would parse the entire specification in one pass (well within its 1M+ token window), then produce a structured analysis: first, a risk matrix highlighting the lack of rate-limiting strategy on pages 12-14 and the circular dependency between the auth service and logging pipeline described on page 28. Next, three improvements: consolidating the redundant endpoint definitions in sections 4 and 9, introducing a circuit-breaker pattern for the external payment provider, and standardising error codes across all routes. Finally, it would flag the OAuth2 flow on page 35 as incompatible with the refresh-token rotation policy documented elsewhere, citing specific line numbers from both sources.

This example showcases the model's massive context window — ingesting a full technical document without chunking or summarisation loss. The multi-step reasoning (risk identification, improvement generation, cross-reference checking) demonstrates the model's ability to hold complex instructions while processing large inputs. Trade-off: at $50/Mtok output, a verbose response here could cost $2-3, making it expensive for iterative review workflows.

I'm attaching a screenshot of a broken dashboard layout in our analytics tool. Explain what's causing the CSS overflow issue and write the fix.

In this illustrative example, the model would analyse the uploaded screenshot, identify that the `.metrics-panel` container has `overflow: hidden` but its child `.chart-wrapper` uses `position: absolute` with no bounding constraints, causing the chart to render outside the visible area. It would then provide a corrected CSS snippet: set `.metrics-panel` to `position: relative` and constrain `.chart-wrapper` with `max-width: 100%` and `right: 0`. The explanation would reference visible UI elements in the screenshot (the clipped bar chart, the scrollbar position) to confirm the diagnosis.

This example highlights native image understanding without requiring separate vision API calls. The model can debug visual layout issues directly from screenshots, useful for front-end troubleshooting. Trade-off: while the model can describe what it sees, it cannot interact with live DOM or browser dev tools, so complex dynamic layout bugs may need follow-up questions.

Generate a Python script that reads this 80MB CSV of transaction logs, detects anomalies using z-score, and outputs a summary report with visualisations. Assume the CSV is already uploaded.

In this illustrative example, the model would produce a complete script: imports for pandas, numpy, and matplotlib; a function to load the CSV in chunks (to handle the 80MB size efficiently); z-score calculation across transaction amounts with a configurable threshold; anomaly flagging logic that marks outliers and groups them by merchant ID; and a matplotlib block generating a histogram of normal vs. anomalous transactions plus a time-series plot showing anomaly clusters. The script would include error handling for malformed rows and a final print statement summarising total anomalies found and their aggregate value.

This example demonstrates end-to-end code generation for a realistic data task, including file handling, statistical analysis, and visualisation — all from a single prompt. The model's large context window means it can reference the uploaded file structure if provided. Trade-off: the script is illustrative; real-world CSV quirks (encoding issues, missing columns) may require iteration, and the model cannot execute the code to verify correctness.

When 1M+ token context justifies the premium on legal work

A 12-person legal ops team needs to compare redlines across 40+ vendor agreements simultaneously—each contract averaging 15-20 pages with exhibits. GPT-6 Astra's 1.05M token window lets you load the entire negotiation history in one context, then ask "which clauses conflict with our standard indemnity language" without chunking or retrieval lag. At $10 input / $50 output per Mtok, a typical 800k-token analysis run costs $8 input + $2 output if you generate a 40k summary. That's expensive compared to Claude 3.5 Sonnet ($3 input / $15 output), but Sonnet's 200k window forces you into a RAG pipeline that adds engineering overhead and risks missing cross-document dependencies. If you're running fewer than 20 of these analyses per month, the engineering cost of building retrieval outweighs Astra's price premium. For teams doing this daily, Astra is the straightforward call.

Why Astra's multimodal support doesn't justify the output cost here

A 5-person e-commerce moderation team processes 2,000 product images daily, flagging policy violations and writing rejection reasons. Astra handles image + text, but at $50/Mtok output, generating a 150-token explanation per image costs $0.0075—$15/day or $450/month at volume. GPT-4o runs the same task at $15/Mtok output ($0.00225 per image, $4.50/day, $135/month) with comparable accuracy on straightforward classification. Astra's massive context window doesn't help here because each image is an independent decision. The 3.3x cost difference only makes sense if you're also using the same model for long-context work elsewhere in your stack and want to consolidate vendors. Otherwise, route this task to GPT-4o or Gemini 1.5 Flash and save the budget for scenarios where the 1M+ window actually matters.

When Astra's context window collapses a multi-step research workflow

A 3-person investment research team analyzes 60+ earnings transcripts each quarter, cross-referencing management commentary against prior quarters and 10-K filings. Traditional approach: chunk documents, embed them, retrieve relevant passages per query, then synthesize. Astra's 1M+ token context lets you load 12 quarters of transcripts (roughly 600k tokens) plus the latest 10-K in a single prompt, then ask "how has the CFO's language on margin pressure evolved since Q2 2023" without retrieval overhead. At $10 input per Mtok, loading 800k tokens costs $8 per analysis session. If you're running 15-20 of these deep-dives per quarter, that's $120-160 in input costs—cheaper than paying an engineer to build and maintain a RAG pipeline for three people. The output cost ($50/Mtok) stays reasonable because you're generating summaries, not long-form content. For small research teams doing infrequent but deep document work, Astra eliminates the RAG tax.