The 1M Token Context Window in Practice

What 1,050,000 Tokens Holds

The easiest way to understand Astra's context window is in concrete terms. One million tokens is not an abstract capacity — it corresponds to specific amounts of real-world content, and knowing those figures helps you design prompts that use the space deliberately rather than guessing what will fit.

A useful rule of thumb: one printed page of text is roughly 300 tokens. A word-processed document runs closer to 500 tokens per page when you account for headers, whitespace, and formatting. With those anchors, here is what 1,050,000 tokens actually holds:

The practical boundary is not 1,050,000 tokens of content — it's 1,050,000 tokens total, including your instructions, system prompt, conversation history, and document content. For tasks that push the upper end, keeping instructions tight and front-loaded is not optional.

Use Cases That Were Previously Impossible

The shift from 128k to 1M tokens is not only quantitative. Several workflow categories change from impractical to viable at this scale.

Full-repository code review in one pass. A large production codebase of 80,000 to 100,000 lines fits inside a single Astra request. Previously, code review at this scale required stitching together multiple calls, maintaining state across sessions, or accepting that the model never had the full picture. With Astra, you can ask for a cross-cutting analysis — security patterns, consistent error handling, architectural coherence — with every file present simultaneously. The model can reference a decision made in one module against its implementation in another without you managing the context manually.

Cross-document synthesis across 50+ papers. Research synthesis that previously required careful manual chunking — load five papers, extract key points, reload five more — can now run in a single request. Feeding 50 to 100 research papers on a narrow topic lets the model identify where authors agree, where they contradict, and which claims cite the same original source. This was previously only possible with retrieval-augmented generation, which introduced its own artifacts and missed cross-document connections the model couldn't see because the papers were never in context together.

Full legal case file analysis. A single case file involving depositions, evidence documents, prior rulings, and correspondence can run 300,000 to 600,000 tokens. Loading the complete file lets the model find inconsistencies between a witness deposition and their emails, or flag that a cited precedent was later reversed — connections that require holding the whole picture simultaneously.

Full product backlog review. A multi-year backlog with detailed tickets, acceptance criteria, and historical comments can be analyzed for duplicates, dependency chains, and misaligned priorities in one pass. Teams that previously spot-checked a subset of tickets can now present the complete backlog and get a systematic review against stated product goals.

Structuring Long-Context Requests

A 1M token window does not mean you can dump arbitrary content and get reliable results. Astra has known failure modes at long contexts that shape how you should structure large requests.

Front-load instructions. Put your task definition before documents, not after. This is the most important structural practice for long-context work. When the model processes 600,000 tokens of documents followed by a three-line task instruction, the instruction arrives late — and the task framing competes with a huge volume of prior content for the model's attention. Lead with what you want, in detail, before any document content begins.

A reliable structure for long-context requests:

1. System prompt or task definition — precise, at the very top
2. Evaluation criteria and output format instructions
3. Document content
4. A brief restatement of the core task at the end

That final restatement addresses the lost-in-the-middle problem: a documented pattern where attention is strongest for content at the beginning and end of the context window, and weakest for material buried deep in the middle. When you push 900,000 tokens of documents, content sitting in the middle receives significantly less attention than content at the edges. Repeating the task instruction at the end ensures it registers strongly even after a long document section.

Chunking strategies for extreme sizes. When your content approaches the 1M token limit, selective loading often outperforms full-context stuffing. For a codebase review, loading the architecture overview, the core module, and the specific file under review — rather than all 800,000 tokens — reduces noise without losing the relevant context. For synthesis tasks, a two-pass approach — extract key findings in the first pass, synthesize in the second — can outperform a single pass where the model is simultaneously reading and synthesizing near the token limit.

Attention dilution. A practical failure mode when feeding large unstructured inputs is that the model's attention spreads thinly across too much content. This produces responses that technically address the question but miss connections that should be obvious, or that draw from earlier sections while ignoring relevant later ones. High-signal, structured content produces better long-context results than the same volume of unstructured content. Passing clean source files outperforms passing a concatenated log dump of equivalent size.

Output Limits and Practical Caps

A 1,050,000-token input window does not produce a 1,050,000-token output. GPT-6 Astra's maximum output is 128,000 tokens — roughly a 90,000-word document. That cap applies regardless of input size: even with 900,000 tokens of source material, the model's response is bounded at 128k output tokens.

For most tasks this is not a practical constraint — 128k tokens is already a book-length output. The cases where it matters are requests that ask for large transformations: converting a 500-page document to a new structure, generating an exhaustive test suite for a large codebase, or producing detailed summaries with extensive quotes. In these situations, the output cap requires a planning decision: either narrow the scope of what you're asking the model to produce in a single response, or break the task into segments.

The 272k billing threshold. There is a second practical cap that affects cost rather than output: prompts exceeding 272,000 input tokens are billed at 2× the standard input rate for the entire request, not just the tokens above the threshold. A 300,000-token prompt costs 2× for all 300,000 input tokens. The standard input rate is $10 per million tokens; above 272k that request is billed at $20 per million. For high-volume pipelines, structuring requests to stay under 272k tokens where possible halves the per-call input cost.

When to stage large tasks. If a task requires more than 128k tokens of output, it must be staged. Define segments upfront — "produce the architecture overview first, then each implementation module in order" — rather than asking for everything in a single request that will be truncated at the limit. Staged tasks are also easier to review incrementally: validating a 20,000-word section at a time is more practical than checking a 90,000-word single response end to end.