AI Coding Agent Landscape: From Tool Selection to Architecture

0. Why a selection report is needed

Between 2024 and 2026, coding tools moved from inline completion to autonomous, multi-step execution. IDE vendors, model vendors, cloud platforms, and open-source projects make different architectural assumptions. A poor choice can remain invisible during a trial and surface months later as engineering debt, a compliance incident, or team friction.

This report compares Cursor, Trae, Claude Code, Codex, Antigravity, Hermes-Agent, OpenCode, and Pi-Agent/OMP through three questions:

1. What actually decides tool selection when autonomous execution becomes normal?
2. Which capabilities remain durable enterprise assets and which are temporary workflow conveniences?
3. How should a field delivery engineer (FDE) combine tools under pressure, restricted access, and parallel customer work?

1. Executive assessment

The comparison uses architecture, engineering depth, enterprise controls, and FDE fit rather than a feature-count leaderboard.

• Codex is the strongest candidate for a centrally governed deployment when a unified App Server, cloud sandboxes, and enterprise network boundaries are priorities.
• Cursor remains a strong personal-development and IDE-first reference, especially for visual diffs, parallel tasks, and local repository work.
• Claude Code is the most portable CLI-first option for a field engineer who needs to start quickly on a restricted machine.
• OpenCode and Pi-Agent/OMP offer the deepest control for teams that need open models, self-hosting, command-level policy, or low-level tool customization.
• Antigravity and Hermes-Agent are useful when the workflow calls for cloud-managed or persistent remote agents, but they introduce deployment and governance requirements of their own.

The deeper conclusion is that the model is increasingly a constant while the Harness is the variable. The Harness owns the system prompt and state machine, context budgets, permissions, tool runtime, isolation, and recovery behavior. Those controls affect completion quality and operational risk even when two products call the same model.

Control-plane capabilities—permissions, resource budgets, isolation, tests, MCP boundaries, and business feedback—are durable assets. Fixed role pipelines and hard-coded workflows depreciate and must be reassessed on a six-, twelve-, and eighteen-month horizon.

2. Scope and method

The report treats Antigravity as an agent-first development platform, Hermes-Agent as a persistent server-side agent with a growing local skill library, OpenCode as a model-agnostic open-source TUI, and Pi-Agent/OMP as a minimal session-tree console with low-level extensions. Codex is evaluated across its desktop, CLI, App Server, and cloud-sandbox surfaces.

Evidence is separated into Fact (official documentation or source), Inference (reasonable conclusions from implementation and tests), and Anecdotal (experienced-user reports). Scores should therefore be read as a decision aid, not as a benchmark that replaces a controlled trial.

Three product transitions

1. Entry point: IDE inline completion → multi-file IDE agents → terminal runtimes → cloud execution.
2. Control-plane ownership: AI side panel → independent tool calls → an agent Harness that can own IDE, CLI, and web clients.
3. Autonomy: assistance → collaboration with confirmation → delegated planning, execution, testing, and repair.

3. A layered product framework

Compare products across three axes: interaction entry point, autonomy, and enterprise integration depth.

Layer 1: IDE and editor agents

Cursor, Trae, and Antigravity make the editor an agent dispatch console. Their strengths are visual feedback, local indexing, previews, captured logs, and line-by-line diff review. Cursor and Antigravity are extending toward asynchronous cloud work; Trae’s strengths are Chinese-language access and a low entry price, while its enterprise governance requires careful review.

Layer 2: CLI and terminal agents

Claude Code, Codex, and OpenCode treat the agent as a portable runtime. CLI-first tools compose with pipes and scripts, start without a large desktop environment, and fit bastion hosts and field delivery. Codex adds cloud sandboxes and multiple clients; OpenCode adds model choice, self-hosting, and open policy configuration.

Layer 3: general companions and remote daemons

Pi-Agent is a minimal console with session branches and deep customization. OMP extends it with hashline editing, LSP integration, native debuggers, and sandboxing. Hermes-Agent is a persistent remote service with cross-session memory, gateways, and a self-improving Skill library. These systems are flexible, but their deployment and governance burden is higher than a local editor.

4. Four implementation patterns

GUI-native / IDE-first

Visual control consoles provide rich diffs, browser previews, and parallel task panels. They are productive for local product work, but their host permissions and indexing behavior need explicit enterprise boundaries.

CLI-first / TUI-first

Terminal agents follow Unix composition. A field engineer can pipe logs into a session, redirect output, and combine the agent with existing scripts without installing a large IDE.

Cloud-native / sandbox-first

Every task runs in a dynamically isolated Linux environment. Background execution, parallel branches, and reproducible environments reduce local setup work, provided data residency and network policy are acceptable.

Self-improving / remote daemon

The agent runs across sessions on a VPS or cluster, accumulating preferences and reusable skills. This can make long-lived operations efficient, but it requires explicit lifecycle, credential, and audit controls.

5. Decision matrix

The following interval ratings are a compact FDE and enterprise-oriented view: A+ is excellent, A strong, B+ good, B adequate, C weak, and D poor. They are directional ratings with different confidence levels, not decimal benchmark results.

Trae’s low enterprise and security rating reflects the absence of the SSO, audit, compliance, and data-governance controls required for sensitive code. Verify current product claims and policies before using any score in a procurement decision.

What drives the ratings

• FDE fit: Codex and Claude Code combine portable entry points with parallel or long-running work. OpenCode adds a model-agnostic route for controlled networks. Hermes-Agent needs a heavier Docker/OpenShell deployment.
• Context: Claude Code’s project instructions and compaction are optimized for long sessions. Codex emphasizes repository-level reasoning. Pi/OMP adds project-scoped memory and session trees.
• Autonomy: Cloud sandboxes and background execution raise Codex and Antigravity’s ceiling. OMP can attach native debuggers instead of repeatedly guessing from an error message.
• Enterprise: Codex and Antigravity can inherit their cloud providers’ identity and network controls. Cursor offers mature team controls, with a meaningful pricing and feature gap between team tiers. OpenCode’s advantage is self-hosting; that shifts more governance work to the customer.
• Security: OpenCode supports granular glob-based policy and protected .env reads. Claude Code exposes tool hooks and permission interception. Cursor’s local command mode and Trae’s data policy require additional host controls for sensitive repositories.

6. Product notes

Claude Code

Claude Code is an Anthropic CLI runtime with a terminal interface, not merely an IDE plug-in. Its strengths are portability, large-repository context management, hooks, permission interception, and composability with existing shell tools. It is a strong default for experienced engineers and FDEs working on restricted machines.

Cursor

Cursor turns a VS Code fork into an agent console. Visual diffs, indexing, background agents, and cloud work make it a productive local development surface. Confirm the command-execution policy and enterprise tier before using it with sensitive source.

Codex

Codex spans CLI, IDE, desktop, App Server, and cloud sandboxes. Its strongest differentiator is a shared control plane that can run isolated tasks in parallel and report state across clients. It is a natural candidate where enterprise identity, data residency, and asynchronous work matter.

Trae

Trae offers an IDE-first experience with Chat, Builder, and SOLO modes, plus strong Chinese-language accessibility. Treat telemetry, data residency, SSO, audit, and compliance as procurement gates; convenience and price do not remove those requirements.

Antigravity

Antigravity’s agent-first desktop, CLI, and managed platform position it between an IDE and a cloud agent service. Parallel missions and enterprise cloud boundaries are its main architectural questions.

Hermes-Agent

Hermes-Agent is a persistent remote daemon with a local Skill library and gateways such as Slack and Telegram. It is useful for long-lived automation, but requires explicit controls for credentials, skill evolution, deployment, and audit.

OpenCode

OpenCode is an open-source, model-agnostic TUI with Plan/Build modes, multiple providers, self-hosting, and detailed command permissions. It is attractive inside a controlled network where the customer owns the model endpoint and data boundary.

Pi-Agent and OMP

Pi-Agent starts from a minimal session-tree console. OMP adds hashline anchors, LSP, native debugger integration, memory, and sandbox extensions. This is the high-control route for teams willing to assemble and maintain their own Harness.

7. Durable architecture patterns

The durable layer is the control plane: permission policy, context budgets, isolation, tool boundaries, tests, and auditable state. Workflow choreography, fixed role divisions, and hard-coded model assignments are more temporary and should be re-evaluated as models improve.

Useful patterns include:

• decoupling the Harness from the IDE so clients become replaceable displays;
• compiling an LLM-maintained knowledge layer instead of relying only on ad-hoc RAG;
• compacting context dynamically while preserving a recoverable session tree;
• applying atomic patches followed by independent hindsight verification;
• delegating subagents with schema-validated boundaries;
• keeping tool calls behind an explicit permission and sandbox policy.

8. FDE use cases and failure modes

For an unfamiliar repository, test context recovery, cross-file repair, style-preserving refactoring, secret protection, long-running parallel work, third-party authentication, ambiguous Chinese requirements, and rapid delivery under pressure. Keep the task, environment, model, permissions, and evidence fixed enough to compare products.

Common failures are predictable: a local IDE cannot run on a restricted host; a cloud agent crosses a data boundary; a free tool lacks audit and identity controls; a self-hosted tool shifts too much operational work to the FDE; a fast agent makes a plausible change without a rollback point.

The practical playbook is to choose one primary control plane, one fallback path, and explicit gates for data access, command execution, tests, and release. Do not select a tool from a single benchmark or a short demo.

9. Enterprise readiness and benchmark plan

Enterprise procurement should verify identity and access management, data residency, audit logs, network egress, credential handling, policy hooks, model routing, support, and the ability to reproduce or delete an agent run. A claimed integration is not a control until it is exercised in the customer’s boundary.

Build a local benchmark with eight tasks: understand an unfamiliar codebase, repair a multi-file bug, refactor to an existing style, protect sensitive credentials, run a long multi-step task, integrate an authenticated third-party API, interpret an ambiguous Chinese requirement, and deliver a fast refactor under a deadline. Measure task success, evidence quality, rollback time, permission violations, context recovery, and total operator effort.

10. Recommendations

Use a three-dimensional decision space instead of a binary “best agent” choice:

1. Control: who owns the Harness, permissions, state, and data boundary?
2. Workflow: which client and degree of autonomy fit this task?
3. Feedback: can the result be tested, observed, audited, and recovered?

For personal IDE work, start with Cursor or another IDE-first tool. For portable field delivery, evaluate Claude Code and OpenCode. For governed asynchronous work, evaluate Codex or Antigravity. For a self-hosted or highly customized Harness, evaluate OpenCode and Pi/OMP. Keep the choice provisional until the eight-task benchmark passes inside the real network and compliance boundary.

The market will converge on agent control planes, policy gateways, model brokers, PR auto-heal gates, and dedicated evaluation systems. The long-term advantage will come from feedback data and safe operating boundaries rather than from a fixed prompt or a single model release.