These tools can all read files, propose edits and run checks. Why, then, do Claude Code, Codex, OpenCode, Pi, GitHub Copilot and Cursor coexist? Is the difference just the model and the color of the window?
The model influences decisions; the surrounding product organizes the work. It determines how you show the project, agree on an approach, intervene and inspect the outcome. Even sharing a model does not make those conditions identical. The introductory map of AI tools explains the basic terms; here we follow the differences through one task.
One feature, different ways of working
Imagine an application with a list of notes. We need to add search by title: the user enters text, the list filters, and a clear message appears when nothing matches. The rest of the behavior must remain intact.
This is an explanatory scenario, not a report of running six agents. The capabilities and published experience below were checked on November 17, 2026. We did not measure speed or code quality and are not choosing a winner.
Every product needs the same answers: where the notes list lives, what “search” means, which changes are allowed and how to verify the feature. Differences begin with how the product helps obtain and retain those answers. An editor tab, a CLI working directory and a cloud repository copy provide different starting conditions.
A product name does not identify the workplace
A CLI is controlled from a terminal. An IDE is an editor with development tools; its agent works beside the code. A desktop application provides a separate workspace. A cloud session means code and checks run in a remote environment. The window can be local while execution is remote.
Changes are often shown as a diff: a comparison of files before and after an edit. “Copilot versus Codex” without identifying the mode is therefore incomplete. Completing a line, performing agentic work in an editor and handling a delegated cloud task are different interactions even within one product.
| Product | Surfaces to distinguish | What matters for our task |
|---|---|---|
| Claude Code | CLI, IDE integrations, desktop, cloud through the web and other clients | A ready-made conversational loop, permission modes, planning and ways to redirect work. |
| Codex | CLI, IDE extension, Codex mode in ChatGPT desktop, Codex Cloud | A steerable project session, visible actions and edits, dedicated review; local and cloud execution are separate. |
| OpenCode | CLI, desktop, web | A shell separate from model providers, with configurable agents, instructions and permissions. |
| Pi | Terminal agent; components for custom integrations | A minimal extensible core: workflows can be added, but every ready-made mode should not be assumed. |
| GitHub Copilot | Editor modes, CLI, Copilot app, GitHub/cloud | Connections to repositories, tasks and change review; capabilities depend on mode and access. |
| Cursor | Agent workspace/editor, CLI, Cloud Agents | Context beside the code, editable plans, change review and separate remote environments. |
The table does not mean that every surface has identical features. Components for building a custom client, for example, are not automatically a finished desktop application.
First, show the right project
For notes search, the agent needs the list component, data and project rules. Context is what the model can access while deciding; opening a session does not make every file in a directory already read.
In a local CLI, you identify the working directory and investigation direction. In an editor, it is easier to point to an already open file or selection, as explicitly documented for the Codex IDE extension. In Cursor and Copilot’s editor workflows, chat, code and change review share an interface. This can reduce the need to explain which passage you are looking at, but does not guarantee the agent finds every dependency.
Persistent instructions add another layer. They can describe the project and required checks. OpenCode V2 documents AGENTS.md for this; other products have their own rules and mechanisms. An instruction saying “do not change data” is different from an enforced write restriction.
In the cloud, our notes application needs the appropriate repository, dependencies and test data. Codex Cloud, Claude Code cloud and Cursor Cloud Agents describe their own execution environments. They do not automatically inherit arbitrary laptop state. A separate workplace is useful, but introduces environment preparation and consistency work.
Agree on intent before the first large diff
“Search by title” leaves questions open: should matching ignore case, update while typing, and show what when nothing matches? An agent can write correct code for a misunderstood requirement.
What matters here is how intent gets agreed. Cursor Plan Mode describes research, clarification and a plan the user reviews and edits before implementation. Copilot CLI also documents plan mode alongside ask/execute. Claude Code’s Plan mode limits work to investigation and planning without source-file edits. The same word “plan” can cover different actions and boundaries.
OpenCode V2 explicitly separates Build and Plan: Plan does not edit ordinary project files, but can write its own plan files; shell operations remain permission-controlled. That is more precise than treating every planning mode as entirely free of side effects.
Pi chooses a different starting set. Its version 1.5.2 README describes no built-in plan mode or delegation to other agents; extensions can supply the organization you need. This does not mean “Pi cannot plan.” A person can request a plan in conversation, but a dedicated mode and a textual agreement are different mechanisms.
Codex local sessions also support investigation, planning and steering. For our example, the important question is whether the agreed requirement remains available during implementation, regardless of the button or mode name.
Branch · Authors' experienceOptional · you can skip this section
Why more built-in features are not always more convenient
In his November 30, 2025 post, Pi creator Mario Zechner explains wanting a simpler, more predictable tool and control over context. This is a developer’s experience and a design motivation; his criticism of other tools at that time should not be presented as their current state.
In Dynamic planning with agents, January 30, 2026, Cursor’s team emphasizes an explicit plan refined during work. That is the manufacturer’s position, not independent evidence of superiority over Pi.
Our conclusion from these approaches: some people benefit from more organization supplied upfront, while others value changing it themselves. The tradeoff is between an integrated process and control over its construction, not between the intelligence of the models.
Allow changes while retaining ways to intervene
After search is agreed, the agent can edit the component and tests. Permission to edit the project is not the same as permission to install packages, contact the network or alter an external database.
Codex documentation separates the sandbox — enforced execution boundaries — from approval of actions beyond those boundaries. Claude Code has permission modes and checkpoints for file changes; these do not undo an external service action. OpenCode’s permission rules specify actions and resources. Such differences affect when users see a request and what can happen without one.
Pi’s README explicitly states that there is no built-in system restricting filesystem, process, network or credential access; the process inherits its environment’s access. Stronger boundaries require separate isolation or integration. Fewer confirmation prompts do not automatically mean greater safety or autonomy.
The other side of control is steering. If the agent starts searching note bodies instead of titles, it must return to the requirement. Products provide different interruption, message-queue and session-continuation mechanisms. For a person, this is the difference between a visible conversation that is easy to follow and a process whose intent is hard to reconstruct. Exact behavior depends on the client and version, so one window’s convenience cannot be projected onto every mode.
See the result and understand what was checked
The agent shows an edit. A diff helps trace exactly what changed in the files. In an editor, you can compare it with open code; in a CLI, it can be part of the conversation or available review tools; cloud work must return a result accessible from its environment.
Codex CLI documents dedicated review of changes, and Cursor provides Agent Review. GitHub Copilot also reviews pull requests — proposed repository changes. These are additional checking mechanisms, not guarantees that no defects remain. A review feature’s existence does not mean it ran automatically or is included in every mode and plan.
For our search feature, ask concrete questions: are titles filtered, what happens without matches, and does clearing the field restore the full list? “Checks passed” must connect to which checks actually ran. A good diff interface makes work visible; correctness needs separate evidence.
Extensions can change this part of the process too. A skill is a packaged procedure with instructions and resources; a plugin adds capabilities. Together with project rules, they can organize a familiar workflow. Check support for the specific surface: a local extension does not become available in cloud execution merely because both share a product name.
One subscription does not mean identical billing in every shell
Access to the application, model and execution environment can be billed differently. Even sign-in matters: subscription authentication and an API key can consume different allowances. This is a short map as of November 17, 2026, not a price list or personal calculation. “Credits” describe a service’s own accounting; their units and conditions are not necessarily identical.
| Product | Access a subscription may cover | What still needs checking |
|---|---|---|
| Claude Code | Individual Pro/Max/Ultra plans provide Claude Code access. | Shared limits, API authentication and any included API-credit conditions. |
| Codex | ChatGPT sign-in uses access associated with that plan. | Limits and Codex Cloud eligibility; API accounting is separate, including any credit conditions. |
| OpenCode | Optional Go and documented ChatGPT Plus/Pro sign-in using plan allowances. | The connected provider and what its sign-in actually covers; this is not compatibility with every subscription. |
| Pi | Open-source shell; the model connects through a supported sign-in method or API. | The software license does not include model or integration charges. |
| GitHub Copilot | Plans include CLI and Copilot app with differing usage allowances. | AI credits, available models, cloud access and organization policies. |
| Cursor | Current X Subscription includes a shared Cursor/Grok pool; legacy Cursor plans also exist. | Third-party models, cloud eligibility and extra charges; old and new plan conditions differ. |
“I already pay for AI” therefore does not establish what another client covers. Nor does the API label prove a scenario is always more expensive: that depends on usage and specific terms. It needs a separate billing analysis, not a conclusion drawn from a feature table.
The same action, different organization of work
All six products can participate in a similar process for adding search. The workplace, visibility of context, supplied approval stages, execution boundaries, steering and ways to construct a workflow will differ.
That creates practical differences: using mostly ready-made organization or building more of it yourself; following a local session or handing work to a prepared remote environment. These are not rigid, permanent camps — products evolve and combine approaches.
Next time you work with your chosen agent, follow five things: how it obtained context, where intent was agreed, which actions are allowed, how you can redirect it, and what confirms the outcome. These explain much of the difference hidden behind a model’s name.