GPT-5.5, agents that forget and RAG that reasons on its own

Today’s most important AI news

A Friday packed with movement on three simultaneous fronts: OpenAI makes a launch focused on offensive and defensive security with GPT-5.5, research on autonomous agents shows both their progress and their structural cracks, and the enterprise RAG field takes a leap toward architectures that reason while they search. It’s not a single-headline day — it’s a day that shows where the whole industry is moving.

OpenAI arms the defenders: GPT-5.5 arrives with special access for cybersecurity

OpenAI announced the expansion of its Trusted Access for Cyber program with two new models: GPT-5.5 and GPT-5.5-Cyber. The second is a variant specifically aimed at vulnerability research and protection of critical infrastructure. Access isn’t public — it’s restricted to “verified defenders”, meaning organizations and researchers who go through a validation process before they can use the model’s most advanced capabilities in security contexts.

This matters because it marks a clear stance from OpenAI: frontier AI in cybersecurity won’t be openly available. Instead of launching the model and dealing with abuse afterwards, they’re betting on a controlled distribution model from the start. It’s the same old dilemma — tools that serve to defend also serve to attack — but with an institutional solution rather than a technical one.

For security teams in Latin America, the practical question is: can we qualify for that verified access? For now, the program seems geared toward large organizations able to meet audit requirements. If your company works in critical infrastructure or vulnerability research, it’s worth exploring the verification criteria OpenAI is publishing on its site. Those who get there first will have months of advantage over their peers.

The silent problem with coding agents: they forget the constraints

Research published on arXiv this week describes a phenomenon any dev who has used coding agents will have noticed but perhaps couldn’t name: “Constraint Decay”. The systematic study shows that LLM agents for backend code generation work well when instructions are simple, but under strict specifications — specific architectures, particular ORMs, mandatory design patterns — their adherence to constraints degrades progressively as the task gets longer.

The central finding is that current benchmarks penalize this behavior poorly. They measure whether the code works, not whether it respects the project’s structural constraints. That means a model can get a high score on standard evaluations and still generate code that completely violates your team’s architecture standards. It’s code that runs, but that shouldn’t exist in that form in your codebase.

For product managers and tech leads evaluating how ready coding agents are for production use, this paper is a concrete argument for including structural-adherence tests — not just functional tests — in any serious evaluation. If your team has architecture guidelines, the relevant question isn’t “does the agent generate code that works?” but “does it generate code we would have written?”. The difference between the two questions can cost your project weeks of technical debt.

Agentic RAG: when the model searches, reasons and searches again on its own

Two papers published this week point in the same direction: classic RAG — retrieving relevant documents and passing them to the model — is being replaced by architectures where the model itself decides what to search for, evaluates what it found, and launches new searches based on what’s missing. AgenticRAG (arXiv) proposes a lightweight harness over existing enterprise search infrastructure that gives the model tools to iterate on its own retrievals. LatentRAG goes a step further: it removes the explicit intermediate steps and makes reasoning and retrieval happen in latent space, reducing the latency of the agentic process.

What connects both works is the shared diagnosis: the bottleneck of traditional RAG isn’t the model’s quality, but that the model arrives late to the decision about what information it needs. When retrieval happens before the model has fully processed the question, the set of retrieved documents is inevitably suboptimal. The solution is to have the model participate in the search, not just in the answer.

For teams with enterprise knowledge bases — technical documentation, contracts, support databases — this is the most practical advance of the week. The first-generation RAG systems many built in 2024 already have an expiration date. The architecture worth exploring now isn’t “embed and retrieve”, but “an agent that interrogates its own search”. Neither paper requires replacing existing search infrastructure — both propose layers on top of what you already have.

In a nutshell

What today reveals isn’t an isolated advance but a pattern of uncomfortable maturation: AI is reaching contexts where errors have real consequences — code in production, critical infrastructure, business decisions based on documents — and the industry is discovering, somewhat late, that the evaluations it used to build confidence didn’t measure what matters in those contexts. OpenAI solves it with access control. The Constraint Decay researchers flag it with tougher benchmarks. RAG teams attack it with more reflective architectures. The common pattern is that “it works” is no longer enough as a criterion — the question is whether it works under real-world constraints, and that question is only just starting to be taken seriously.

---

Sources used: https://openai.com/index/gpt-5-5-with-trusted-access-for-cyber, https://arxiv.org/abs/2605.06445, https://arxiv.org/abs/2605.05538, https://arxiv.org/abs/2605.06285