You open your IDE, point the AI at a module, say "refactor this," and walk away. Twenty minutes later you return to find it rewrote file 16 in a way that contradicts everything it decided in file 3. The AI forgot. Again.

Two and a half months ago, OpenAI said they fixed this. GPT-5.2-Codex launched on January 14 with a headline promise: context compaction — an agent that remembers what it's doing across long sessions. The coding community collectively held its breath. Now it's late March, the hype cycle has completed its rotation, and we have enough real-world mileage to ask the only question that matters: did it actually deliver?

The pitch was compelling. Every AI has a context window — its working memory, how much text it can "see" at once. During a long coding session, that window fills up. When it overflows, the model forgets earlier decisions and starts contradicting itself. Context compaction lets GPT-5.2-Codex intelligently compress what's in that window — keeping the important bits, discarding noise. In theory, this is the difference between an agent that handles a 30-minute task and one that survives a 3-hour refactoring marathon without amnesia.

OpenAI also baked in cybersecurity detection — the model spots vulnerabilities during code generation, not as a separate scanning step. On benchmarks, GPT-5.2-Codex hit top scores on SWE-Bench Pro and Terminal-Bench 2.0. Windows support got a dedicated boost too, which took only... several years.

Here's what two months of production use have shown. Context compaction works — partially. For sessions under an hour, the improvement is real and noticeable. Your agent keeps its thread, remembers architectural decisions from file 3 when it reaches file 16. But push past the two-hour mark on a large codebase and the cracks appear. Compaction is lossy by definition — it has to discard something — and the model's judgment about what's "noise" doesn't always match yours. Subtle invariants get compressed away. Type constraints established early in a session vanish. It's better than raw context overflow, significantly better, but "solved" is a stretch.

The security claims? I'll believe those fully when someone publishes a comprehensive red-team report, not a press release. Most real-world vulnerabilities aren't obvious patterns a model can spot — they're subtle architectural mistakes, timing bugs, logic errors buried in business rules. "Detects vulnerabilities during generation" sounds great in a keynote. In production, the bugs that actually hurt you are the ones no model sees coming. Community reports so far suggest it catches the low-hanging fruit — SQL injection patterns, obvious buffer issues — but misses the architectural-level flaws that cause actual breaches.

Strategically, this was always a catch-up move, and the market treated it accordingly. Claude Sonnet 4.5 owned the coding model throne for months before this launch. Cursor built its own models. Windsurf shipped SWE-1.5. OpenAI watched the agentic coding market leave without them and responded. A solid response — but a response, not a lead. Two months later, Claude's position hasn't meaningfully eroded. The coding agent wars turned out to be about tooling and workflow integration, not just raw model capability.

The pricing remains the sharpest decision in the whole package: $1.75 per million input tokens (a token is roughly ¾ of an English word — it's how AI measures and bills text) and $14 per million output tokens. Identical to base GPT-5.2. No premium tier, no upsell. That's a direct shot at every competitor charging extra for coding-specific models, and it's held up. Windsurf had to give SWE-1.5 away free through March just to stay in the conversation — and even that didn't fully work.

The one-model-fits-all era is officially dead. OpenAI shipping a purpose-built coding derivative confirmed what the market already figured out: writing code autonomously is a fundamentally different job from chatting. But the deeper lesson from these two months is that context management — not intelligence, not benchmarks — is the actual bottleneck in agentic coding. GPT-5.2-Codex pushed that boundary forward. It didn't eliminate it. Your refactoring agent now remembers what it was doing in file 3. Whether it still remembers by file 47 depends on how lucky you feel.