Cursor Release Notes: Explicit Prompt Caching for GPT-5.6

What changed

Cursor's latest release notes describe a change that is technical and largely invisible to users, but it addresses one of the biggest recurring costs in AI-assisted coding. Starting with GPT-5.6, OpenAI's API lets clients mark explicit cache breakpoints in addition to the platform's default implicit caching 1. Cursor now places those breakpoints after the stable layers of each request and before the conversation history, which keeps growing. The goal is for later turns in a session to reuse more of the prompt prefix that hasn't changed 1.

In practice, much of what an AI coding assistant sends to a model stays the same from one turn to the next: system instructions, tool definitions, and project context. The part that changes is the expanding back-and-forth between developer and agent. Implicit caching handles some of this automatically. Explicit breakpoints let Cursor tell the API exactly where the reusable portion ends, so it doesn't have to rely on the provider's inference.

Why it matters

Prompt caching matters most in long, multi-turn sessions, which is exactly how agentic coding tools are used. An agent iterating on a refactor or debugging a failing test can resend a large and mostly identical prefix many times. Every token the model can reuse from cache is a token it doesn't have to reprocess.

The release note doesn't give figures for latency or cost savings, and none should be assumed 1. Still, the direction is clear. Cursor is tuning how it builds requests so that its most stable material sits in front, where caching can capture it, and the volatile material sits at the end. This is plumbing work, and plumbing tends to decide whether agent-heavy workflows stay affordable as sessions get longer.

How it fits Cursor's trajectory

The caching change fits a pattern visible across Cursor's development over the past year and a half. A retrospective of the company's 2025 updates identifies version 0.50, released in May 2025, as a turning point 2. That release introduced Background Agents, which run coding tasks independently while developers work on other things 2. The same release replaced the token-based pricing common among early AI tools with unified request-based pricing. It also made Max Mode available for top models under token-based pricing and added @folders support for context management 2. Smaller changes included a refreshed Inline Edit with faster file edits, plus chat export and duplication 2.

The releases from August to September 2025 shifted toward teams and enterprises. Version 1.5 added a Linear integration so developers could launch Background Agents directly from issue tickets 2. It also introduced a /summarize command that condenses long chat histories as they approach context limits 2. Version 1.7 brought Agent Autocomplete for command suggestions and Hooks in beta, which are custom scripts that observe and control agent behavior at runtime 2.

A common thread: managing context

The two sources cover different periods and different kinds of updates. One is a single granular note about API caching 1. The other is a broad survey of feature launches 2. Read together, they share a theme: much of Cursor's engineering effort goes toward managing context.

@folders support was about getting the right material into a request 2. /summarize was about shrinking a conversation once it grew too large 2. The new cache breakpoints are about cheaply reusing what doesn't change while the conversation grows 1. Each targets a different point in the same problem. Coding agents need a lot of context to be useful, and context costs money and time.

The pricing history explains why this matters commercially. Moving to request-based pricing in 2025 was presented as a way to replace confusing token-based schemes 2, while Max Mode kept token-based billing for heavier use 2. Under any of these models, how efficiently a tool uses tokens behind the scenes affects either its own margins or what customers pay. Caching improvements like this one are where those economics are decided.

The takeaway

The caching update is easy to overlook next to features like Background Agents or Hooks. It is arguably just as significant for Cursor's long-term position. As the company pushes developers toward longer, more autonomous agent sessions, the cost and speed of each additional turn become a central constraint. Using OpenAI's explicit breakpoints quickly suggests Cursor sees request efficiency as a competitive edge rather than an implementation detail 1. Whether users notice the change will depend on how much faster or cheaper extended sessions become, which the notes don't quantify.