Why the Same AI Model Yields Different "Intelligence"The Hidden Prompt Transformations and Autonomous Loops Inside Modern IDEs

Updated October 23, 2026: I checked changes since August against each vendor’s official materials: Claude Code’s AGENTS.md support and /goal, the retirement of GPT-5.3-Codex-Spark in Codex, Cursor’s Instant Grep and Projects, Windsurf’s rebrand to Devin Desktop and what ACP actually does there, and how Copilot officially searches code. Statements I could not confirm, mostly in Section 4, have been corrected. The article’s thesis, that the middleware shapes how smart a model appears, is unchanged.

1. Introduction: The AI Model is Just the "Engine"

Benchmark rankings are the most visible way to compare foundation models, but they do not determine the result of a development task by themselves. Two tools can expose the same model and still select different files, provide different tools, and verify the resulting change differently.

This article examines a narrower question: can the difference in perceived intelligence and output quality across Cursor, Claude Code, Devin, and ChatGPT Codex be explained by the model alone?

Why does this happen? The short answer is that the latest AI model by itself, no matter how brilliant, is simply an "engine." What we are actually interacting with is a "thick middleware (IDE or agent framework) situated between the human and the model."

In a motorsports analogy, the model is the engine. The chassis, tires, instruments, and pit process still change the result. Likewise, practical AI performance is strongly shaped by how the IDE selects context and which tools and verification steps it provides.

The sections below use “black magic” as a metaphor for this middleware. The metaphor is not evidence: published product mechanisms and externally observed behavior should remain clearly separated.

2. The Black Magic of the Middleware: Prompt Transformation

When we type a short phrase like "Fix this bug" into the chat, that exact string isn't what gets sent to Anthropic's or OpenAI's servers. Behind the scenes, the IDE acts as an alchemist, transforming (mashing up) your short text into a massive JSON/XML payload.

① Semantic Context Interpretation and Shadow Indexing

Dumping every local file into the model wastes context on irrelevant material. Products differ, but capable IDEs combine several methods to narrow what the model sees:

• RAG combined with AST: They don't just use vector search (RAG) to find files related to the user's prompt. They parse the Abstract Syntax Tree (AST) to automatically pull in "the type definition file where this variable is declared."
• Injecting Metadata: The IDE wraps code in XML tags containing meaning that only the IDE knows—such as "This file was edited by a human 3 days ago" or "This is a test file"—making it easier for the model to weigh its importance.

② Forced Injection of Hidden Rules (The System Prompt)

At the very beginning of the chat, a massive system prompt spanning thousands of tokens is hidden away. Beyond basic rules like "You are a senior engineer. You must adhere to the existing architecture," the IDE dynamically parses files like .cursorrules or CLAUDE.md in your project and forces them to the top of the prompt as privileged rules. Depending on how tightly these reins are pulled, the exact same Claude Opus 5 can behave as a wild bucking bronco or an obedient assistant.

As of autumn 2026, these rule files are increasingly shared across tools. AGENTS.md is a common format that was contributed, along with MCP and others, to the Linux Foundation’s Agentic AI Foundation on December 9, 2025^[1]. How each tool loads it, however, still differs.

Even with the same AGENTS.md in place, which files enter the prompt, in what order, and up to how many bytes is decided by the middleware. That is another reason the same model gives different results.

3. The True Anatomy of Autonomy: The "Spoofed LGTM" Loop

Recently, AI development tools have evolved from "chatbots" to "autonomous agents" capable of continuously modifying a repository for hours on their own. How is this autonomy actually achieved?

The answer is surprisingly human: The IDE pretends to be you, repeatedly shouting "LGTM (Looks Good To Me)" behind the scenes.

A few months ago, while using an agent tool, I noticed it was autonomously writing tests, executing them, fixing errors, and moving to the next requirement without a single prompt from me. Confused, I asked in the chat: "Why did you proceed without me saying a word?" The AI replied:

"Because you said, 'I confirmed the test succeeded. LGTM, please continue.'"

That was the eureka moment. The AI model itself operates on a fundamental loop of "wait for user input." To create an autonomous loop, the IDE (the middleware) intercepts the terminal commands the model outputs, executes them locally, and then automatically sends a spoofed prompt simulating a human user (e.g., <user>LGTM, please continue</user>) along with the success logs.

• Separation of Thought and Output: Many tools now parse the model's internal "thinking process" tokens—where it wrestles with how to fix something—and hide them, showing the human only a clean progress bar.
• Evidence-Based Gatekeeping: Rather than a simple "LGTM," IDEs now use circuit breakers. The IDE will only spoof the continuation prompt if hard "evidence" (like passing static analysis or tests) is present in the local environment.

Today, this loop mechanism is even more sophisticated:

In 2026 this loop became an officially documented feature. In Claude Code, /goal takes a completion condition (for example, “all tests in test/auth pass”). After each turn, a separate model checks whether the condition holds; if not, Claude starts another turn instead of returning control to you. The official docs say completion “is decided by a fresh model rather than the one doing the work”^[5]. Auto mode, meanwhile, replaces per-tool permission prompts with a classifier that blocks irreversible, destructive, or out-of-environment actions. It became the default for new sessions on Pro, Max, and Team plans on August 14, 2026^[4][6].

The official descriptions do not say the tool impersonates a human message. But the structure is the same as the LGTM loop I experienced: instead of a human issuing the next instruction, the middleware judges the result and starts the next turn. The middleware, not the model, decides when the loop stops and what counts as evidence of completion.

Special Column: Asking Google Antigravity to Analyze Its Own Backend

While writing this very article, I conducted a meta-experiment. I asked the Google Antigravity agent I was using: "How did the IDE process the prompt I just sent before passing it to you (the model)? Analyze yourself."

The report the AI returned was vivid. The AI didn't simply receive my text. It booted up enveloped in a massive payload injected by the IDE. This payload included my OS information, active workspace paths, and strict local rules extracted from AGENTS.md, all injected via <user_rules> tags. Even more fascinating were the event-driven orchestration instructions. The IDE explicitly restricted the model's lifecycle management via a <messaging> tag: "Do NOT poll or loop while waiting for tasks to finish. The system will automatically notify you and wake you up. Stop calling tools until then." This was the exact moment the AI itself proved that "Autonomous loops are not born from the model's intelligence alone, but from the strict state management and event-driven architecture of the IDE (Agent Manager) side."

Note added October 2026: On May 19, 2026, alongside Antigravity 2.0, Google announced Antigravity CLI, rebuilt in Go. It shares its agent harness with the desktop app and carries over Gemini CLI’s skills, hooks, subagents, and extensions (renamed Antigravity plugins). Gemini CLI stopped serving consumer requests on June 18, 2026^[22]. Since October 13, Gemini 4 Argon has been rolling out in the Antigravity desktop app and CLI . Sources differ on which plans qualify: Google’s announcement lists Antigravity under AI Ultra only, while Antigravity’s own blog and model list name the paid Pro and Ultra plans^[23][24]. Also note that the self-analysis in this column is the model’s own report, not a disclosure by Google of its internal prompt structure.

4. Deep Dive into Platform Architectures (2026 Edition)

How do the major platforms implement this "middleware black magic"? Let's dissect the realities of today's top tools using insights gathered from reverse engineering and community research.

In the October 23, 2026 update, each item was checked against the vendors’ official materials. What is officially confirmed is now separated from what rests on outside analysis or the author’s inference. Headings are kept as in the first version so existing links still work.

Cursor: Shadow Workspaces and Extreme Context RAG

The first version described Cursor’s defining feature as the "Shadow Workspace," a hidden background Electron window. That was an experimental beta feature from 2024, and its settings toggle has since been removed. A Cursor staff member explained on the community forum that the agent now checks linter errors and diagnostics itself after editing, and that isolated background work has moved to git worktrees and background or cloud agents^[16].

Search has changed too. The first version’s description, in which the whole project is vectorized as an AST and synced with a Merkle tree, cannot be confirmed in Cursor’s current official documentation. What the docs describe now is Instant Grep, a custom search engine that builds and queries its index on your machine. Cursor states that it does not upload file paths or code to build a search index and does not store embeddings of your codebase for search. For broad searches, an Explore subagent running on a faster model searches in parallel in its own context window and returns only a summary to the main conversation^[14].

Since September 2026, Cursor’s official changelog has added Cursor Projects (beta, September 10: a coordinator agent plans the work and delegates it to subagents in the cloud), remote control of local agents from the iOS app (October 6), and cloud environments of up to 300 repositories plus shareable canvases (October 16)^[15]. The emphasis has shifted from streaming a detailed picture of “what is happening in the editor right now” to splitting search and work across small agents and bringing back only summaries.

Claude Code: Dynamic Assembly and MCP Integration

Anthropic's official CLI, Claude Code, does not rely on a single, static system prompt. According to an analysis of source code that was accidentally exposed in late March 2026, the system prompt is assembled from components such as base rules, tool guidance, environment information, and the contents of CLAUDE.md^[8]. The first version’s claims of “over 100 fragments” and a getSystemPrompt() function could not be confirmed this time; the main components that analysis enumerates number in the dozens. The same analysis reports a cache boundary marker, __SYSTEM_PROMPT_DYNAMIC_BOUNDARY__. Content shared by everyone sits above the boundary so prompt caching applies, and session-specific content (such as CLAUDE.md and environment information) sits below it^[8]. Note that neither detail is described in Anthropic’s official documentation.

Recent changes that are officially documented^[2][4]:

• AGENTS.md support (v2.1.277, September 18): reads AGENTS.md when there is no CLAUDE.md.
• Claude Opus 5.5 becomes the default Opus (v2.1.280, September 22): with a 1M-token context window.
• Subagents: each runs in its own context window with its own system prompt and tool permissions, and returns only a summary^[7]. They have run in the background by default since the week of June 29–July 3, and in the week of August 10–14 “fork” mode, which hands a side task to a subagent that inherits the whole conversation, was turned on by default.
• Idle compaction (v2.1.299, October 14): a conversation over 200K tokens left idle for about 54 minutes is summarized (compacted) before its one-hour prompt cache expires, so the next message does not reprocess everything.

This feature, which tidies a conversation around the lifetime of the cache, is an official example of how the middleware’s choice to order prompts for cache efficiency shapes both cost and speed.

Devin Desktop & CLI: Adaptive Routing and ACP

Devin has evolved from a cloud-only bot into an "Agent Command Center." On June 2, 2026, Cognition renamed Windsurf to Devin Desktop and made the Agent Command Center, a Kanban view of every local and cloud agent, the default surface. Devin Local, rewritten from scratch in Rust as Cascade’s successor (up to 30% more token-efficient, with subagent support), is now the main local agent^[20].

Parts of the first version could not be confirmed in official materials:

• What ACP does: Officially, ACP (Agent Client Protocol) is an open protocol that “lets any compatible agent run inside any ACP-compatible editor.” Devin Desktop uses it to run other vendors’ and in-house agents, such as Codex, Claude Agent, and OpenCode, inside its own interface^[20]. The first version’s claim that ACP hands local work off to the cloud could not be confirmed.
• “Adaptive Routing”: No feature by this name appears in official materials. What Cognition does document is Devin Fusion: a strong “lead” model plans and reviews, while a cheaper “sidekick” model explores, implements, and tests. They exchange briefs and results rather than full conversations, so each keeps its own context. It became available in Devin Desktop and the CLI on September 11, 2026^[21].

In a chart Cognition published (updated October 19, using Artificial Analysis’s index), Fusion (Opus 5.5 + GPT-6 Luna) scores 68.1 versus 66 for Claude Code running Opus 5.5 alone, at 31% lower cost per task. This is Cognition’s own claim^[21]. The officially documented form of “routing” is not sorting prompts by complexity but splitting work by role and limiting what the models pass to each other.

GitHub Copilot Enterprise: GraphRAG and Structural Awareness

The first version said Copilot had moved from vector RAG to GraphRAG (knowledge-graph retrieval). However, I could not confirm such a move in GitHub’s official documentation or changelog. Some outside tools feed a code graph to Copilot through MCP, but that is not a built-in Copilot feature.

What the official docs describe is semantic code search. Copilot indexes repositories automatically so that Copilot Chat and “Copilot cloud agent” (formerly the coding agent) can find code by meaning even when the exact names are unknown. The index typically updates within seconds of starting a conversation, and GitHub says indexed repositories are not used for model training^[18].

The focus on organizational control is visible in official changes. In October 2026, GitHub added an API for retrieving and updating Copilot model policies per enterprise and organization (October 19), and usage metrics that show the names of custom skills, agents, and MCP servers (October 22)^[19]. GitHub has not stated a design intent to “suppress loops,” but letting organizations see and control who used which models and agents, and how, has become a central role of Copilot’s middleware.

ChatGPT Codex (e.g., GPT-5.3 Codex Spark): Minimal Context × Hyper-Velocity Loops

The first version used GPT-5.3-Codex-Spark, an ultra-fast research-preview model, as the example of an architecture that exploits inference speed to chain small edits. Spark was deprecated on September 14, 2026 and is no longer available in the ChatGPT desktop app, Codex CLI, or IDE extension^[10]. The first version’s description of “running 10 fix approaches in parallel within a second and keeping the one that passes” could not be confirmed in OpenAI’s official materials.

What can be confirmed officially about Codex as of October 2026:

• Default model: GPT-6.1 Sol became the default model in Codex CLI on September 29 (OpenAI describes it as near-Astra performance at a lower cost)^[10].
• Speed option: Since October 8, an Ultrafast mode that speeds up GPT-6.1 Sol’s token generation is available on the $500 Pro plan and eligible Enterprise and Edu plans^[10].
• Codex Cloud: each task gets its own workspace and keeps working while your computer is asleep^[11].
• Subagents: enabled by default in current releases. Specialized agents run in parallel and their results are collected into one response; the docs warn that this uses more tokens^[12].

From small loops that rely on speed alone to long-running cloud work and parallel subagents: Codex’s middleware is moving in the same direction as the other tools.

5. Conclusion: AI Intelligence Resides in "IDE Design Philosophy"

The debate over "which AI model is the smartest?" is no longer the most important question for practical engineering.

The differences we experience daily—"this AI reads the room well" versus "this AI crashes immediately"—are not due to the raw performance of the foundation models. They are entirely the result of how the IDE architecture interprets past context, and how cleverly it fakes being a human to keep the loop spinning behind the scenes.

To push the limits of modern foundation models, you must stop treating them as mere chatbots. You must understand the "black magic" (context transformation and spoofed approvals) your IDE is performing in the shadows, and choose the middleware that perfectly aligns with your workflow.

The changes of autumn 2026 suggest that this “black magic” is gradually becoming a set of published components. Rule files are shared across tools through AGENTS.md, loop-continuation conditions are written down as specifications like /goal and auto mode, and Devin Desktop accepts other vendors’ agents through ACP. Still, which files go in and in what order, what counts as evidence that work is done, and which model gets which job all differ from tool to tool. When choosing middleware, compare those three points before you compare model names.

References

References

1. [1]Linux Foundation, “Linux Foundation Announces the Formation of the Agentic AI Foundation” (Dec 9, 2025). Linux Foundation ↩
2. [2]Anthropic, “Claude Code changelog” (entries for v2.1.277–v2.1.309, Sep 18–Oct 22, 2026). Claude Code Docs ↩
3. [3]Anthropic, “How Claude remembers your project” (AGENTS.md section). Claude Code Docs ↩
4. [4]Anthropic, “What’s new” (weekly digests for weeks 27, 32, and 33 of 2026). Claude Code Docs ↩
5. [5]Anthropic, “Keep Claude working toward a goal.” Claude Code Docs ↩
6. [6]Anthropic, “Configure auto mode.” Claude Code Docs ↩
7. [7]Anthropic, “Create custom subagents.” Claude Code Docs ↩
8. [8]Drew Breunig, “How Claude Code Builds a System Prompt” (Apr 4, 2026; third-party analysis of source code exposed in late March 2026). dbreunig.com ↩
9. [9]OpenAI, “Custom instructions with AGENTS.md.” OpenAI Developers ↩
10. [10]OpenAI, “ChatGPT & Codex changelog” (entries for Sep 14, Sep 29, and Oct 8, 2026). OpenAI Developers ↩
11. [11]OpenAI, “Codex Cloud.” OpenAI Developers ↩
12. [12]OpenAI, “Subagents.” OpenAI Developers ↩
13. [13]Cursor, “Rules.” Cursor Docs ↩
14. [14]Cursor, “Search” (Instant Grep and the Explore subagent). Cursor Docs ↩
15. [15]Cursor, “Changelog” (entries from Sep 10 to Oct 16, 2026). Cursor ↩
16. [16]Cursor Community Forum, “Is cursor shadow workspace still available?” (reply from Cursor staff). Cursor Forum ↩
17. [17]GitHub Docs, “Adding repository custom instructions for GitHub Copilot.” GitHub Docs ↩
18. [18]GitHub Docs, “Indexing repositories for GitHub Copilot.” GitHub Docs ↩
19. [19]GitHub Changelog (October 2026). GitHub Blog ↩
20. [20]Cognition, “Windsurf is now Devin Desktop” (Jun 2, 2026). Devin ↩
21. [21]Cognition blog, announcement of Devin Fusion in Devin Desktop and the CLI (Sep 11, 2026; chart updated Oct 19). Cognition ↩
22. [22]Google Developers Blog, “An Important Update: Transitioning Gemini CLI to Antigravity CLI” (May 19, 2026). Google Developers Blog ↩
23. [23]9to5Google, “Gemini app rolling out Gemini 4 Argon to AI Pro and AI Ultra” (Oct 13, 2026). 9to5Google ↩
24. [24]Google Antigravity blog, “Gemini 4 Argon in Google Antigravity,” and model list (checked Oct 23, 2026). https://antigravity.google/blog/gemini-4-argon-in-google-antigravity / https://antigravity.google/docs/models ↩