Warp, the Rust-based AI terminal with over 700,000 active developers, made a landmark move in April 2026: the entire terminal client is now open source on GitHub under the AGPL-3.0 license. Alongside it, the Oz cloud agent orchestration platform shipped under MIT. This is the most significant shift in terminal tooling since Ghostty launched in late 2024.

For developers who dismissed Warp as "just another closed-source terminal with AI bolted on," the open-source release changes the calculus entirely. You can now audit the Rust codebase, contribute features, build custom integrations, and understand exactly how block-based output, GPU-accelerated rendering, and agent mode work under the hood.

This guide covers everything you need to know: the open-source architecture, licensing implications, key features, how to get started, the Oz platform, MCP integration, and how Warp fits into the broader agentic development landscape. Whether you're evaluating Warp for your team or planning to contribute, this is the complete reference.

1Why Warp Going Open Source Matters

Warp's decision to open-source its client is not just a PR move. The terminal market in 2026 is split between minimalist open-source options (Alacritty, Kitty, Ghostty) and feature-rich proprietary tools. Warp was the only AI-first terminal that kept its code closed, which created friction with developers who wanted transparency around telemetry, data handling, and the AI pipeline.

By releasing the client under AGPL-3.0, Warp addresses the biggest objection head-on. Developers can now inspect exactly what data flows to Warp's servers, how the AI agent communicates with LLM providers, and what the GPU rendering pipeline does at every step.

The contribution model is unique: Warp uses an "agent-first workflow" managed by Oz, their cloud agent orchestration platform. Community members can submit issues and feature requests, and Oz agents help triage, implement, and test contributions. This is a new model for open-source governance that blends human review with AI-assisted development.

For the broader ecosystem, this means the terminal is no longer a commodity layer. It's becoming an agentic development environment (ADE) where AI agents operate alongside developers, and having that code open lets the community shape how that future unfolds.

2Licensing: AGPL-3.0 vs MIT Explained

Warp uses two different licenses for its open-source components, and understanding the distinction matters if you plan to build on top of the code.

The AGPL-3.0 license on the terminal client is the stricter of the two. If you modify Warp's client and offer it as a network service (SaaS), you must release your modifications under the same license. This prevents competitors from forking Warp, adding proprietary features, and selling it as a closed product.

The MIT license on Oz is deliberately permissive. Warp wants developers and companies to build on the orchestration layer without licensing friction. You can embed Oz in proprietary toolchains, commercial products, or internal platforms without open-sourcing your code.

For most developers using Warp as a daily terminal, the licensing has zero practical impact. It only matters if you plan to fork and redistribute the client or build a competing product on top of the codebase.

3Warp Architecture: Rust, GPU Rendering & Blocks

Warp is built entirely in Rust, which gives it memory safety without garbage collection overhead. The rendering pipeline uses GPU acceleration to draw the terminal UI, making it significantly faster than Electron-based terminals like Hyper and competitive with Alacritty and Ghostty on raw rendering benchmarks.

The block engine is what makes Warp fundamentally different from traditional terminals. Every command and its output are grouped into a discrete "block" that you can select, copy, share, or reference independently. This is not just a UI feature - the block model changes how the terminal manages state, scrollback, and agent context.

The GPU renderer uses Metal on macOS, Vulkan on Linux, and DirectX on Windows. Text rendering, cursor animation, and UI elements are all GPU-accelerated, which keeps the terminal responsive even with thousands of lines of output.

The shell parser handles command interpretation, autocompletion for 400+ CLI tools, and syntax highlighting. With the code now open, developers can extend the parser to support custom CLI tools and domain-specific completions.

4Core Features for Developers

With the open-source release, every feature in Warp's client is now inspectable. Here are the capabilities that matter most for daily development work.

Block-Based Output

Every command execution creates a block containing the input, output, exit code, and timing metadata. Blocks are individually selectable, shareable, and searchable. You can copy a block's output without manually selecting text, share it with teammates via Warp Drive, or feed it as context to the AI agent.

IDE-Style Text Editing

The command input area is a full text editor with multi-cursor support, bracket matching, auto-closing quotes, and standard keyboard shortcuts (Cmd+A, Cmd+C, Cmd+V). This eliminates the awkward readline navigation that traditional terminals force on you.

Warp Drive: Team Collaboration

Warp Drive is a shared workspace where teams save workflows (parameterized command sequences), notebooks (interactive runbooks), prompts (reusable AI instructions), and environment variables. It functions like a team knowledge base embedded directly in the terminal.

Smart Autocompletion

Warp provides context-aware completions for over 400 CLI tools, including git, docker, kubectl, aws, npm, and cargo. Completions include flag descriptions, argument types, and usage examples pulled from the tool's documentation.

Cross-Platform Support

Warp runs natively on macOS, Linux, and Windows. The Rust codebase compiles to native binaries on each platform, with platform-specific GPU backends (Metal, Vulkan, DirectX) for optimal rendering performance.

5Agent Mode & Oz Cloud Orchestration

Agent Mode is Warp's core AI primitive. You describe what you want in natural language, and the agent proposes executable commands, chains multi-step workflows, reads command output, and self-corrects when something fails. It operates directly in your shell with your toolchain context.

Behind Agent Mode sits Oz, Warp's cloud agent orchestration platform. Oz handles:

• Cloud agents - Spin up parallel agents on remote infrastructure with configurable compute (2-8 vCPU, 4-16 GiB RAM)
• Multi-model routing - Automatically selects the best model for each task, with support for Claude, GPT-4o, Gemini, Kimi, MiniMax, and Qwen
• Environment management - Define Docker images, repos, and setup commands for reproducible agent execution
• Integrations - Trigger agents from Slack, Linear, webhooks, or cron schedules
• Audit trails - Full visibility into what each agent did, which commands it ran, and what it changed

The Oz CLI (oz) lets you run cloud agents from any terminal, script, or CI/CD pipeline. This means you can integrate Warp's agent capabilities into existing automation without switching your entire workflow to the Warp terminal.

6MCP Integration & Extensibility

Warp supports the Model Context Protocol (MCP) for extending agent capabilities. MCP servers act as plugins that expose external tools and data sources to Warp's agents through a standardized interface.

Warp supports multiple MCP connection protocols including Streamable HTTPS and SSE, along with custom headers and environment variables. This means you can connect agents to:

• GitHub, GitLab, and Bitbucket for repository operations
• Linear, Jira, and Asana for project management
• PostgreSQL, MySQL, and MongoDB for database queries
• AWS, GCP, and Azure for cloud resource management
• Figma for design-to-code workflows
• Custom internal APIs and microservices

The Warp Bridge VS Code extension also connects external AI coding agents (Claude Code, Codex, Gemini CLI) to Warp via MCP, letting those agents run commands, open tabs, and spawn other agents inside Warp.

With the codebase now open, developers can build custom MCP servers that integrate deeply with Warp's block model and agent context. This opens up possibilities for domain-specific terminal experiences that were not feasible when the code was closed.

7Warp Pricing & Plans in 2026

Warp uses a credit-based pricing model. The terminal itself is free and open source, but AI features and cloud agents consume credits. Here is the current pricing structure as of April 2026:

All paid plans support BYOK (Bring Your Own Key), letting you use your own API keys for OpenAI, Anthropic, Google, and other providers. This is useful for teams that already have negotiated enterprise rates with LLM providers.

The Build plan also includes frontier model access, credit rollover, and 40 indexed codebases for context-aware agent responses. For most individual developers, the Build plan at $18/month provides the best value.

8Getting Started: Installation & Setup

Warp provides pre-built binaries for all major platforms. You can also build from source now that the code is open.

Quick Install

Build from Source

First Steps After Install

1. Create a Warp account (required for AI features and Warp Drive sync)
2. Set your default shell in Settings > General (bash, zsh, fish, or nushell)
3. Try Agent Mode by pressing Ctrl+Shift+A (or Cmd+Shift+A on macOS) and typing a natural language request
4. Explore Warp Drive by pressing Ctrl+Shift+D to save your first workflow
5. Configure MCP servers in Settings > AI > MCP to connect external tools

9Contributing to Warp Open Source

Warp's contribution model is different from typical open-source projects. The team uses an "agent-first workflow" where Oz agents assist with issue triage, implementation, and testing. Here is how to get involved:

• Report issues - File bugs and feature requests on the GitHub Issues page
• Join discussions - Participate in architecture decisions and feature planning on GitHub Discussions
• Submit PRs - Fork the repo, make changes, and submit pull requests. Oz agents help review and test contributions
• Build MCP servers - Create custom MCP integrations that extend Warp's agent capabilities
• Extend completions - Add autocompletion specs for CLI tools not yet covered

The codebase is primarily Rust, so familiarity with Rust tooling (cargo, clippy, rustfmt) is helpful. The GPU rendering layer uses platform-specific APIs, so contributions to the renderer may require knowledge of Metal (macOS), Vulkan (Linux), or DirectX (Windows).

Warp's team has stated that community contributions will be reviewed by both human engineers and Oz agents, with the goal of merging high-quality PRs within days rather than weeks.

10Why Lushbinary for Agentic Development

At Lushbinary, we build production systems that leverage agentic development environments like Warp. Our team works with AI-powered terminals, MCP integrations, and cloud agent orchestration daily to deliver faster, more reliable software for our clients.

Whether you need help setting up Warp for your engineering team, building custom MCP servers, integrating Oz cloud agents into your CI/CD pipeline, or architecting an agentic development workflow from scratch, we have the expertise to get it done.

❓ Frequently Asked Questions

📚 Sources

• Warp GitHub Repository
• Warp Pricing Page
• Oz Platform Documentation
• Warp MCP Documentation

Content was rephrased for compliance with licensing restrictions. Pricing and feature data sourced from official Warp documentation and pricing pages as of April 2026. Pricing and features may change - always verify on the vendor's website.