Part 5: Agent Deep-Dives O–W

1. OpenCode

Go Apache-2.0 5k+ Stars

Architecture: Client/Server with Deep LSP Integration

OpenCode takes a distinctive client/server approach built in Go. The TUI client is built with Bubble Tea (a Go TUI framework) and communicates with the OpenCode Server over gRPC. This separation enables the server to manage long-running sessions independently of the terminal interface, supporting features like shareable links and multi-session workflows. An internal Event Bus coordinates communication between the LSP Client, MCP Client, and core server logic.

LSP Integration: Semantic Code Intelligence

OpenCode’s standout feature is its comprehensive Language Server Protocol integration. Rather than relying solely on text-based grep and file reads, the agent leverages structured semantic understanding of the codebase through 9 LSP methods:

• goToDefinition — Jump to where a symbol is defined
• findReferences — Locate all usages of a symbol across the project
• hover — Retrieve type information and documentation
• documentSymbol — List all symbols in a file
• workspaceSymbol — Search symbols across the entire workspace
• goToImplementation — Find concrete implementations of interfaces
• prepareCallHierarchy — Map function call relationships
• incomingCalls — Which functions call a given function
• outgoingCalls — Which functions a given function calls

Auto-Detected LSP Servers

Additional Features

• Provider Agnostic: Supports 75+ LLM providers via the Models.dev registry
• AGENTS.md: Project-specific configuration file for custom instructions, similar to Claude’s CLAUDE.md
• Multi-Session: Run and switch between multiple concurrent sessions
• Shareable Links: Export session state as shareable URLs
• Claude Pro Support: Direct integration with Anthropic’s Claude Pro subscription

2. OpenManus

Python MIT 53.9k Stars

Architecture: 4-Level ReAct Agent Hierarchy

OpenManus implements a layered agent architecture where each level adds progressively more capability. The base layer provides memory, state management, and LLM connectivity. The ReAct layer adds the Observe → Think → Act loop. The ToolCall layer enables structured tool invocation. Finally, the Manus layer combines everything into a fully autonomous coding agent. This design achieves 74.3% on the GAIA benchmark for general AI assistant tasks.

PlanningFlow Orchestration

Complex multi-step tasks are managed through PlanningFlow, which creates an explicit plan using the PlanningTool before execution begins. Each step in the plan is executed through the full agent hierarchy, and the plan itself is monitored and adjusted dynamically as steps succeed or fail. This explicit planning layer is critical for tasks that require coordination across multiple files or systems.

Tool Inventory

OpenManus ships with 15+ built-in tools spanning shell execution, file manipulation, web interaction, and agent coordination:

3. Qwen Code

TypeScript Apache-2.0 17.9k Stars

Architecture: Forked CLI with Qwen Optimizations

Qwen Code is a TypeScript CLI forked from Gemini CLI and customized for the Qwen model family. It achieves 67–69.6% on SWE-bench Verified depending on the underlying model variant. The most notable feature is its free tier offering 2,000 requests per day via OAuth authentication — no API key required — making it the most accessible agent for developers without cloud billing.

Tool Inventory (13 Tools)

Cross-Session Memory

The save_memory tool enables explicit persistence of information across sessions. Unlike implicit memory systems that rely on conversation history, this gives the agent (and user) direct control over what knowledge is retained. This is especially useful for project-specific conventions, architectural decisions, or debugging context that should survive session boundaries.

4. Replit Agent

Python Proprietary

Architecture: Multi-Agent System with Python DSL

Replit Agent uses a multi-agent architecture with three specialized agents: a Manager Agent that decomposes tasks and coordinates execution, an Editor Agent that handles code modifications, and a Verifier Agent that validates outputs. The most significant architectural innovation is replacing traditional JSON function calling with a Python DSL for tool invocation, yielding ~90% tool invocation success rate, 15% cost savings from fewer turns, and 30% faster execution.

Python DSL vs. Traditional Function Calling

The Python DSL approach is Replit’s most impactful engineering decision. Traditional JSON function calling limits the agent to one tool call per generation step, with no conditional logic. The Python DSL allows multiple tools, branching, and loops in a single generation:

# TRADITIONAL (JSON Function Calling):
# { "name": "edit_file", "arguments": {...} }
# => One tool per generation, no conditional logic

# REPLIT (Python DSL):
file_content = read_file("src/app.py")
if "def hello():" in file_content:
    edit_file("src/app.py", ...)
    run_command("python -m pytest tests/")
# => Multiple tools, conditional logic, single generation

Trajectory Compression

Replit supports 200-minute autonomous sessions, which can generate enormous context windows. Trajectory compression addresses this by condensing long session histories into key decision points. Instead of retaining every file read and tool call, the system identifies critical state transitions — plan changes, test failures, architectural decisions — and preserves only those.

Production Scale

Replit Agent’s cloud sandbox includes a checkpoint system that captures full environment state at key moments, enabling rollback and branching. In a partnership with Rokt, the system demonstrated its production readiness by building 135 applications in 24 hours. The Verifier Agent adds a self-testing layer where the agent writes and runs its own test suites to validate correctness before marking a task complete.

5. Vibe CLI (Mistral)

TypeScript Apache-2.0

Architecture: Config-Driven Agent Framework

Vibe CLI is Mistral’s open-source coding agent, built around a ~/.vibe/ configuration directory that organizes agents, prompts, and history as structured files. Custom agents are defined via TOML configuration, making it straightforward to create specialized agents for different tasks without modifying source code. The Devstral model family powers the backend, achieving 72.2% on SWE-bench Verified with the flagship 123B model.

Devstral Model Family

Cost Comparison

The Devstral family offers the most cost-effective per-token pricing among agents with competitive SWE-bench scores:

6. Warp

Rust Proprietary

Architecture: Agent Development Environment (ADE)

Warp redefines what a coding agent can be by building an entire Agent Development Environment with a GPU-rendered Rust UI. It achieves the highest SWE-bench Verified score at 75.8% (with GPT-5) among all agents analyzed in this series, and scores 52% on Terminal-Bench. The team’s core thesis: “A single agent with focused tools outperforms multi-agent approaches.”

Full Terminal Control (FTC)

Warp’s most significant innovation is Full Terminal Control — a PTY-based system that gives the agent the ability to drive interactive terminal sessions. Unlike traditional agents that can only execute commands and read stdout, FTC enables the agent to handle prompts, confirmations, pagination, SSH sessions, and even interactive editors like vim.

Cloud Sandbox Architecture

Key Engineering Decisions

• Single-Agent Philosophy: Warp deliberately chose a single-agent architecture with focused, high-quality tools over a multi-agent system. Their benchmarks show this outperforms approaches that distribute work across multiple specialized agents.
• GPU-Rendered UI: The Rust + GPU rendering pipeline delivers sub-frame latency for terminal output, critical when the agent is streaming real-time log output or navigating interactive sessions.
• Codebase Embeddings: Semantic search over the codebase via embeddings enables the agent to find relevant code by meaning rather than just text matching, improving context retrieval for complex tasks.
• SOC 2 Compliance: The cloud sandbox (Namespace) is SOC 2 compliant, making Warp viable for enterprise environments where security and auditability are requirements.

Quick Reference: All 6 Agents

Themes Across O–W Agents