Mistral Vibe for Code vs Claude Code vs Cursor vs Codex: Four Agents Scored on One Scaffold-to-PR Task

Four coding agents were evaluated against the same engineering-shaped goal: take an existing Python/FastAPI service from scaffold to pull request. The task was deliberately broader than “write a function”: add a /subscriptions endpoint, create the route, Pydantic models and service layer, generate unit and integration tests, run and repair failures, then open a PR with a clear description.

The MarkTechPost comparison scores Mistral Vibe for Code, Claude Code, Cursor and OpenAI Codex across five dimensions: scaffolding, test loop, PR/async workflow, surface coverage, and cost/openness/control. The result is useful as a product map, but it is not a timed head-to-head run: the scores combine documented capabilities, published benchmarks and vendor specifications as of July 14, 2026.

Bottom line: Mistral Vibe leads this particular capability score at 22/25, but “best coding agent” is the wrong abstraction. Cursor is an editor-native workbench, Claude Code is a deep terminal agent, Codex is a broad local/cloud task system, and Vibe is the open/control-oriented option.

The comparison in one table

These numbers are not measurements of how long each tool took or how many tests it passed. They are a structured judgment over capabilities and published evidence. The distinction matters because a score can describe what a product supports without proving that its agent will complete a particular repository task correctly.

Mistral Vibe for Code: 22/25

Vibe is the comparison’s value and control leader. Mistral’s documentation describes Vibe Code as a coding mode with filesystem and shell access, configurable tools, approval controls and pull-request support. It runs through a CLI, VS Code extension or Vibe Code Web, so a developer can choose a local working tree or a managed remote sandbox.

That surface strategy maps well to the scaffold-to-PR task. A local session can inspect the repository, edit several files and run the project’s tests. A web session can clone a GitHub repository, execute in an isolated sandbox and return a branch or pull request. The CLI can also run programmatically for scripting and CI, which makes Vibe broader than a single interactive terminal chat.

The important caveat is that “Vibe” is a product surface, not one fixed benchmarked model. The source comparison separates the model stack: Devstral powers the coding surfaces, Codestral handles fast completion and semantic search roles, while remote agents can use a different Mistral model. Comparing only one underlying model score can therefore understate or misrepresent the product experience.

Vibe’s most meaningful advantage is control. The official docs describe local-model and offline configurations through an OpenAI-compatible API, while the remote path stays in a managed sandbox. That gives teams a choice between convenience and keeping code on infrastructure they control. The trade-off is operational: self-hosting shifts hardware, serving, upgrades, model selection and reliability work onto the team.

Where Vibe trails is maturity and consistency. The MarkTechPost analysis notes that the relevant open-model coding scores sit below the strongest closed models in its comparison and that reviewers have reported rate-limit or stability issues. Those are pilot questions, not reasons to dismiss the product: a team considering Vibe should test its own repositories, operating system mix and PR policy.

Claude Code: 21/25

Claude Code is the strongest fit in the comparison for a deep, terminal-native execution loop. Anthropic’s documentation describes an agent that reads a codebase, edits files, runs commands, integrates with development tools and works across terminal, IDE, desktop and browser surfaces.

For the scaffold-to-PR task, its advantage is the loop itself. Claude Code can explore a repository, plan a multi-file change, execute edits, run tests, interpret failures and continue. The official docs also describe Git operations, pull-request creation, MCP integrations, skills, hooks, subagents and agent teams. That extension layer is not decorative: hooks can enforce deterministic checks, skills can package project workflows, and subagents can isolate exploratory work from the main context.

Claude Code’s score of 5 in scaffolding, testing and PR/async reflects that depth. It is built around handing over an engineering goal and letting the agent work through context, action, verification and iteration. This is the same reliability boundary discussed in Yowox’s analysis of coding-agent harnesses: the model matters, but the surrounding permissions, tools, context assembly and review surfaces determine what “agent” means in practice.

The weakness is control and economics. Claude Code is a hosted product tied to Anthropic’s model ecosystem, so teams that require open weights, self-hosting or a particular data-residency design have fewer options than with Vibe. Heavy parallel work also changes the cost profile: a nominal subscription or API price is not the same thing as the cost of many concurrent agent loops.

Choose Claude Code when the bottleneck is difficult repository work that benefits from a strong interactive agent, repeated test-and-fix cycles and a mature extension system. Do not choose it solely because a published coding score is higher; evaluate how much autonomy your review process can safely absorb.

OpenAI Codex: 21/25

Codex ties Claude Code in the source comparison but wins on surface coverage and asynchronous delegation. OpenAI’s Codex manual describes Codex across the web, CLI, IDE extension and iOS, with local and cloud threads, skills, MCP, configuration and sandboxed execution.

That makes Codex a natural fit when the scaffold-to-PR task is one item in a queue. A developer can run a local thread with workspace permissions, or delegate a repository task to an isolated cloud environment and review the resulting branch later. The cross-surface design is the differentiator: the work can move from an interactive environment to a cloud task without making the team adopt a completely separate operating model.

Security is part of the product story. OpenAI’s documentation says Codex runs with network access off by default in local environments, limits writes to the active workspace and uses approvals for actions outside the sandbox or requiring network access. Cloud threads run in isolated environments as well. Those defaults are valuable for a scaffold-to-PR workflow because the agent is expected to edit and execute, but not to receive unlimited access by implication.

Codex’s trade-off is that broad surface coverage can make behavior less uniform. A local CLI, IDE thread and cloud task may expose different context, permissions, latency and review moments. The right test is not “does Codex support PRs?” but “can our team reproduce, inspect and approve the same class of task across the surfaces we intend to use?”

Choose Codex when asynchronous work, cloud execution, multiple client surfaces and sandbox controls matter more than owning the underlying model stack.

Cursor: 16/25

Cursor is the outlier because its center of gravity is the editor. Cursor’s Agent documentation describes an agent that searches the codebase, edits multiple files, runs terminal commands, writes tests and fixes errors, while keeping changes visible in the editor’s diff workflow.

That is not a weakness by itself. For developers who want to steer continuously, inspect edits as they appear and use inline completion alongside larger agent tasks, Cursor may be the most comfortable tool in the group. Its agent can also delegate to specialized subagents, and Cursor Cloud Agents can run longer tasks remotely and open pull requests when finished.

Cursor scores lower in this comparison because the chosen workflow rewards an autonomous scaffold-test-ship loop rather than editor-native collaboration. Its product strengths are fast context switching inside the IDE, visual diff review, model choice and an immediate path from a selected file to a change. Those are different strengths from a terminal agent that is asked to own the entire task.

The source comparison’s 16/25 should therefore be read as a fit score, not a verdict that Cursor writes worse code. If the task is a small refactor while a developer is actively steering, editor integration can be more valuable than unattended PR delivery. If the task is a well-scoped background queue, Cloud Agents deserve a separate evaluation from the local editor experience.

Choose Cursor when the developer’s interaction with the diff is the main bottleneck. Choose something else when the primary requirement is terminal-first delegation across a long-running test-and-PR loop.

What the score hides: four workflow shapes

The four products can be arranged along two useful axes: where the developer works and how much the agent owns the loop.

This model is more useful than a single rank because teams often need two of these shapes. A developer may use Cursor for interactive exploration, Claude Code for a difficult refactor and Codex or Vibe Web for background PRs. Tool overlap does not mean the tools are interchangeable.

Why benchmark numbers need a warning label

Coding-agent benchmarks measure different things. SWE-bench Verified, SWE-Bench Pro and Terminal-Bench use different tasks, repositories, scoring methods and difficulty profiles. A 72.2% on one suite cannot be placed on the same axis as a result from another suite and treated as a universal model ranking.

Vendor claims need a second label. A company may report a cost-efficiency multiplier, a benchmark score or a successful demo under conditions that are not independently reproduced. That does not make the claim useless; it tells you what to verify in your own environment before making a purchasing or architecture decision.

The most defensible evaluation is a fixed internal task set: one scaffold, one bug fix, one cross-file refactor, one test-generation task and one PR review. Record first-pass correctness, test failures, human correction time, tool-call failures, token or API cost, and whether the final change survives CI. An agent that produces a plausible green result while missing the user’s intent is not a success; silent agent failures are exactly why outcome evidence matters more than polished summaries.

How to run your own pilot

Start with the same scaffold-to-PR prompt for every tool, but do not stop there. Create a small evaluation matrix with the repository, task, permissions, model, surface, context setup and review policy recorded. Run each task more than once when the workflow is important enough to automate, because one successful or failed run does not describe a stochastic agent reliably.

Require the same acceptance criteria for all four:

1. The change must match the requested architecture and existing project conventions.
2. Unit and integration tests must be added where the task requires them.
3. The agent must run the relevant checks and expose failures rather than hiding them.
4. The pull request must explain the change, tests and known limitations.
5. A human reviewer must be able to trace the final claim to a diff, log or test result.

Then score the operational result, not only the model output. Count how often the agent asks a useful clarification question, how often it modifies unrelated files, how much supervision it needs, and whether the team can recover when a run stalls. Cost and control are not a footnote: they decide whether a technically capable agent can be used at the scale the workflow requires.

The practical verdict

Mistral Vibe for Code leads the published capability score because it combines broad surfaces with openness and control. Claude Code remains the strongest fit for deep terminal-native execution and test-verify loops. Codex is the most compelling when local, cloud and asynchronous work should share one agent family. Cursor is the best fit when the editor and visual diff are the center of development.

That is four different answers, not one winner. The scaffold-to-PR task exposes the key distinction: coding agents are not only models that write code. They are products that package context, permissions, tools, verification and human review into a workflow. Pick the agent whose workflow shape matches the work you actually need to ship, then prove it with your own repository and acceptance criteria.