Warp 2.0: The Terminal That Became an Agentic Development Environment

Most AI coding tools started as editors and grew AI features on top. Warp went the other way — it started as a terminal and kept expanding outward until the terminal was just one component inside a much larger system.

Warp 2.0 rebrands this evolution as an Agentic Development Environment (ADE): a single app with four pillars — Code, Agents, Terminal, and Drive — where AI agents are first-class citizens rather than optional add-ons. For developers whose work lives in the shell, this is a meaningfully different approach than Cursor or Claude Code. This guide covers what Warp 2.0 actually is, how local and cloud agent modes work, how to configure it with AGENTS.md, and where it fits in the 2026 developer toolkit.

Why Warp's Terminal-First Bet Matters

When Cursor started gaining traction in 2024, the assumption was that AI coding tools would follow the IDE model: a code editor where AI assists with edits, autocomplete, and chat. Claude Code broke that assumption by proving a headless terminal agent could outperform IDE-first workflows for complex agentic tasks.

Warp takes a third path. It built a modern Rust-based terminal first — block-based output, collaborative sessions, searchable history — and then layered a full agent system, a built-in code editor, and cloud orchestration on top. The result is an environment where you can issue a natural-language prompt to run a multi-step DevOps task, review the diff inside the same window, and deploy it as a scheduled cloud agent without ever leaving Warp.

The numbers suggest this is resonating. As of April 2026, Warp has 700,000+ active developers, $73M+ in funding, and scores 75.8% on SWE-bench Verified — which the company says makes it the highest-quality coding agent available when paired with GPT-5. It also holds the #1 position on Terminal-Bench at 52%.

The Four Pillars of Warp 2.0

Warp 2.0 organizes itself around four integrated components.

Code is the built-in editor inside Warp. It lets agents propose file changes in a diff review panel, which you can accept or reject without switching to a separate editor. Warp reports 96%+ acceptance of agent-suggested diffs — a metric that reflects both the editor's diff UX and the quality of agent outputs.

Agents is the core agentic layer. Warp agents run multi-step plans directly in the shell, chain commands, read output, and self-correct. There are two modes: Pair (interactive assistance in the current session) and Dispatch (autonomous execution, where the agent runs independently and notifies you when done). A management UI shows the status of all running agents and sends notifications on completion or when an agent needs input.

Terminal is the foundation everything else builds on. It retains full compatibility with shell workflows, block-based output organization, and the searchable session history that made early Warp popular. Agents interact with the terminal via Full Terminal Use — introduced in November 2025 — which lets an agent run commands, interpret output, and react to errors just as a human would.

Drive is the team knowledge layer. Warp Drive is a shared workspace inside the terminal where you store and sync Workflows, Notebooks, Prompts, Environment Variables, Rules, and MCP configurations. Changes sync immediately, so team members always have the latest version of shared procedures. Drive objects also become part of the AI context — you can tailor agent responses by maintaining shared project rules and documentation in Drive.

How Local Agents Work

Local agents run directly inside the Warp app with access to your shell and file system. The entry point is the universal input bar, which accepts both natural language prompts and terminal commands from the same text field.

When you send a prompt, Warp creates a task list, executes commands in sequence, and presents diffs for review at each file modification. You can approve, reject, or redirect mid-execution. The /plan command produces a spec-driven development plan before any execution begins, which is useful for larger tasks where you want to review the approach first.

A key differentiator from IDE-based agents is Full Terminal Use. Warp agents can actually run shell commands, not just write code — so a task like "set up a staging environment, run the test suite, and open a PR if tests pass" is handled natively, without the agent needing to call external tools or APIs to interact with the shell.

Multi-agent threading lets you run multiple independent tasks simultaneously. The management UI shows each agent's status, and notifications fire when any agent needs input or completes its work.

Configuring Your Project with AGENTS.md

Warp respects a project-level rules file stored in your repository. The current default filename is AGENTS.md; WARP.md is supported for backwards compatibility. If both files exist in the same directory, WARP.md takes priority. The filename must be in all caps for Warp to detect it.

Warp automatically applies the rules from the root directory and the current working directory. For deeply nested projects, it makes a best-effort attempt to include rules from subdirectories when you're editing files there.

A minimal AGENTS.md file looks like this:

# Project Rules

## Setup
Run `npm install` to install dependencies before any task.
The app uses Node 22. Check `nvm use` before running commands.

## Architecture
Next.js 15 with App Router. Do not use the pages directory.
Tailwind CSS v4. Do not add custom CSS unless Tailwind cannot handle it.

## Testing
Run `npm test` before proposing any PR. Fix failures before proceeding.
Integration tests live in `tests/` — do not mock the database.

## Git
Branch naming: `feat/`, `fix/`, `chore/` prefixes required.
Do not push to main directly.

The file is compatible with other agent tools that use similar conventions — Claude Code uses CLAUDE.md, OpenAI Agents SDK uses AGENTS.md with the same format. Standardizing on AGENTS.md means the same file works across multiple coding agents without duplication.

Oz: Warp's Cloud Agent Orchestration Platform

Oz launched on February 10, 2026, as Warp's answer to a fundamental limitation of local agents: they run on your laptop, which means they stop when you close the lid, can't scale to parallel workloads, and require you to manually trigger them.

Oz moves agents into the cloud. It provides:

Trigger mechanisms — You can start a cloud agent run from Slack (tag @Oz in a message), from a GitHub PR event, from a Linear issue, from a CI failure, or on a cron schedule. First-party integrations handle the event-to-agent pipeline automatically.

Parallel execution at scale — Oz is designed to run hundreds of agents concurrently, each in its own isolated environment. Team leads can see status, outputs, and logs across all running agents in one view.

Docker-based environments — Agent runs use predefined Docker environments from the warpdotdev/oz-dev-environments repository. You specify the environment in your agent configuration, and Oz clones the repository and sets up the workspace before the agent starts.

Cron scheduling — Recurring tasks can be scheduled in standard cron format. Example from the Oz docs:

oz schedule create \
  --name "Weekly dependency updates" \
  --cron "0 10 * * 1" \
  --environment env_abc123 \
  --prompt "Check for dependency updates and open a PR"

Multi-repo support — A single Oz agent can work across multiple repositories, which matters for monorepo setups or microservice architectures where a single change spans multiple repos.

Oz is available on the Build plan ($18/month) and above. It's accessible via the Oz web app at oz.warp.dev, through the Warp desktop app, and via the Oz API for programmatic control.

Warp Drive: Team Knowledge That Agents Can Use

Warp Drive is a shared workspace where teams store and distribute knowledge objects. It supports six types:

• Workflows — Parameterized command sequences, like a deployment checklist with variables for environment and version
• Notebooks — Documentation with embedded commands, runnable in sequence
• Prompts — Reusable natural language instructions for agents
• Environment Variables — Shared env configs synced across the team
• Rules — AGENTS.md-style instructions at the team level, not just the repo level
• MCP Configs — Model Context Protocol server configurations shared across the team

The key AI integration: Drive objects are included as context when agents run. If your team has a Drive Workflow for "deploy to production," an agent can reference it directly. Team Rules in Drive supplement project-level AGENTS.md, which means you can maintain organization-wide conventions without putting them in every repo.

Drive sync is real-time — edit a workflow, and every team member has the update immediately.

Warp vs Cursor vs Claude Code: Where Each Fits

These three tools address the same underlying problem — using AI to accelerate development — but from different starting points.

The decision often comes down to where most of your work actually lives. If you spend more time in a terminal than in an editor — infrastructure, backend development, DevOps — Warp's model fits naturally. If you rely on visual code navigation, inline diff review, and editor extensions, Cursor's VS Code foundation is hard to replace. Claude Code offers the most autonomy for complex multi-file operations but lacks Warp's team collaboration features and cloud orchestration.

Some teams run both: Warp for infrastructure tasks and Oz-scheduled automation, Claude Code or Cursor for feature development.

Supported Models and BYOK

Warp supports multiple model backends and lets you bring your own API key:

• GPT-5 and other OpenAI models (the configuration used for the 75.8% SWE-bench score)
• Claude models (including Claude Opus 4.7 for high-effort tasks)
• Gemini models
• BYOK (Bring Your Own Key) — connect any OpenAI-compatible API endpoint

Model selection is available per-agent-run, so you can use a fast model for routine tasks and a more capable model for complex ones. The BYOK option also means you can point Warp at self-hosted models via vLLM or LiteLLM if you're running inference locally.

Pricing

Warp offers four pricing tiers as of April 2026:

The Free tier is enough to evaluate local agents. Oz cloud orchestration requires the Build plan ($18/month) at minimum. For teams, the Business plan at $45/user/month includes the admin controls and expanded Drive features that make team-wide deployments practical.

Practical Setup: Getting Started with AGENTS.md

Here's a minimal configuration that covers most developer use cases:

Step 1 — Install Warp:

brew install --cask warp

Or download directly from warp.dev. The current stable version is 0.2026.04.22.08.46 (April 2026).

Step 2 — Create your AGENTS.md: Place it in the root of your project repository. Warp will pick it up automatically.

# Project Setup

## Environment
Node 22. Run `nvm use` before any task.
PostgreSQL 16 (via Docker). Start with `docker compose up -d db`.

## Commands
- `npm run dev` — development server (port 3000)
- `npm test` — full test suite (unit + integration)
- `npm run build` — production build check

## Code Standards
TypeScript strict mode. No `any` types.
All functions must have explicit return types.
Use Zod for all external input validation.

## Git
Branch from `develop`, not `main`.
PR title format: `[type]: description` (feat/fix/chore/docs).

Step 3 — Initialize an agent run: Open Warp, navigate to your project directory, and type a natural language prompt in the universal input bar. Example:

Refactor the auth middleware to use the new session management API.
Run the test suite and confirm everything passes before showing me the diff.

Warp will create a task plan, execute the required steps, and present the diff for your review.

Step 4 — Set up an Oz cloud agent (optional): For recurring tasks, visit oz.warp.dev and configure a scheduled run. The Oz team has predefined Docker environments available at github.com/warpdotdev/oz-dev-environments that cover common stacks.

Common Pitfalls

AGENTS.md case sensitivity — The file must be AGENTS.md (all caps). agents.md or Agents.md will not be detected.

Pair vs Dispatch mode — Pair mode is interactive; Dispatch mode is autonomous and will proceed without asking for confirmation at each step. Verify which mode is active before running a task that modifies production files.

Drive sync latency — Warp Drive syncs in real time, but new Drive objects may take a few seconds to propagate to all team members' sessions. Don't assume a just-created Workflow is immediately available on a different machine.

Oz environment setup time — Cloud agents need to clone the repo and set up the Docker environment before work begins. For frequently recurring tasks, pre-warming the environment by running a setup agent first reduces this overhead.

Frequently Asked Questions

Q: How does Warp's AGENTS.md differ from Claude Code's CLAUDE.md?

They serve the same purpose — providing project context to the agent — and use compatible Markdown formats. The main difference is scope: AGENTS.md in Warp can be supplemented by team-level Rules in Warp Drive, while CLAUDE.md is repo-local only. For teams using both tools, maintaining a shared core in AGENTS.md / CLAUDE.md with a consistent naming convention reduces duplication.

Q: Can Warp agents work with private repositories?

Yes. Local agents work with any directory on your machine. Oz cloud agents require authentication credentials in your cloud environment, which Warp configures via the environment setup in the Oz web app. GitHub Actions integrations use OAuth for private repo access.

Q: Does Warp require a constant internet connection for agents?

Local agents (Pair and Dispatch modes) require connectivity only to call the model API (OpenAI, Anthropic, etc.). The terminal itself works offline. Oz cloud agents run entirely in Warp's cloud infrastructure and don't need your local machine online once triggered.

Q: What is Terminal-Bench and why does Warp's #1 score matter?

Terminal-Bench is a benchmark designed specifically for terminal-based agent tasks — running commands, interpreting output, debugging failures, and handling long-running processes. Unlike SWE-bench (which focuses on code changes), Terminal-Bench evaluates the full shell interaction loop. Warp's #1 score at 52% suggests it handles terminal-specific workflows better than general-purpose coding agents, which matters for DevOps and infrastructure use cases.

Q: Is there a Linux version of Warp?

As of April 2026, Warp requires macOS 11 or higher. A Linux version has been on the roadmap since 2024 but has not shipped. The Oz cloud agents run in Linux Docker containers regardless of your local OS, so you can use Oz-triggered workflows in Linux CI environments without a macOS client.

Key Takeaways

Warp 2.0 is the most complete "terminal-first" agentic development environment available in 2026. Its core advantages over IDE-first alternatives come from Oz cloud orchestration, Full Terminal Use, and Warp Drive team sharing — features that don't have direct equivalents in Cursor or Claude Code.

For terminal-heavy developers and DevOps teams, the workflow fits naturally. You're already in the terminal; Warp makes that terminal into an orchestration layer for both local and cloud agents. The AGENTS.md project configuration is compatible with other agent tools, which reduces the cost of adding Warp to an existing setup.

Where Warp falls short is on purely edit-centric workflows. If most of your day involves navigating a large codebase visually, using LSP features, and reviewing PRs with inline annotations, Cursor's VS Code foundation gives you tools Warp's built-in editor hasn't matched yet.

The practical recommendation for most teams in 2026: evaluate Warp if more than half your time is in a terminal. The Free tier covers local agent evaluation. Try Oz on the Build plan ($18/month) for one or two recurring automation tasks — if it handles them reliably, the cloud orchestration story alone justifies the cost.