If you found Plandex through a 2024 blog post or a “best CLI coding agents” roundup, you probably noticed something odd when you tried to sign up: the cloud service is gone. Plandex AI, the company, announced in October 2025 that it was winding down its managed cloud after the founder took an engineering role at Promptfoo (itself later acquired by OpenAI in March 2026). New user registration closed October 3, 2025. Existing cloud accounts ran until November 7, 2025, then the managed service shut off entirely.

What remains is a 15.4k-star MIT-licensed Go binary and a Docker-based server you can run yourself. The question for a developer in May 2026 is whether the self-hosted version is still useful, or whether Aider and Claude Code have simply lapped it.

Short answer: Plandex v2 still does something specific that those tools do not do as cleanly — handle enormous multi-file tasks in a single controlled session with a cumulative diff sandbox that keeps AI changes quarantined until you explicitly apply them. For privacy-focused teams or developers running air-gapped environments, that combination is hard to replicate. For everyone else, the setup overhead and maintenance uncertainty make it hard to recommend over the actively-developed alternatives.

What happened to Plandex Cloud

Plandex launched in early 2024 as a company with a managed cloud and an open-source core. The cloud offered two tiers: an integrated plan ($45/month, models included) and a BYO API Key plan ($30/month, bring your own Anthropic/OpenAI keys). Both tiers are gone.

The project has not been abandoned in the sense of being deleted or relicensed — the GitHub repo at plandex-ai/plandex is still up, the code is MIT, and the README actively documents the self-hosted path. There have been no major feature releases since v2.2.1, and the project is in maintenance mode. The plandex.ai website was returning errors at the time of writing (May 23, 2026), though the GitHub install script worked during testing.

If you depend on a vendor standing behind the product, Plandex is not that product anymore. If you are comfortable running open-source infrastructure yourself and accepting that the project’s future is community-dependent rather than backed by a funded team, it is a genuinely capable tool.

What Plandex v2 actually does

Plandex is a terminal-first AI coding agent written in Go, optimized for large projects and long-running multi-step tasks. Where Aider is built around tight git integration and fast iteration on individual files or functions, Plandex is built around what it calls a “plan”: a session that accumulates proposed changes across many files and lets you review, revise, or roll back before anything touches your working directory.

The core technical differentiators in v2:

2M token effective context window. With the default model pack (Claude Sonnet or equivalent), Plandex can hold up to 2M tokens of loaded file content across a session. For reference, that is enough to hold the entire source of a mid-sized production application without selective trimming.

Tree-sitter project maps up to 20M tokens. Even if your repo is too large to load fully into context, Plandex builds a syntax-aware map using tree-sitter (30+ languages supported). This gives the model structural awareness of your codebase — class hierarchies, function signatures, import graphs — without burning tokens on full file content.

Cumulative diff review sandbox. Every proposed change lands in a sandbox, not your files. You get a full diff view before anything is applied. If a 20-file refactor produces three good changes and two bad ones, you apply the three and reject the two without touching git. This is meaningfully different from Aider’s default behavior, which writes directly to files (though Aider’s --dry-run flag exists for similar purposes).

Configurable autonomy. You can run Plandex in full auto mode for straightforward tasks (it will run commands, apply changes, retry on failures) or drop to a fine-grained approval mode where it pauses before each action. The automated debugging loop can read terminal output and browser application state (requires Chrome) to iterate on failures without manual intervention.

Model flexibility. Plandex uses a model pack system where different roles in a task (planning, coding, summarization, error analysis) can use different models. The default pack uses Claude Sonnet for most roles, but you can configure OpenAI, Google, OpenRouter, or Ollama (local, no API key) for any role. There is also failover: if you provide keys for both a direct provider and OpenRouter, Plandex falls back automatically if the first request fails.

Self-hosting in 2026: what you actually need

The self-hosted path has two modes.

Local mode (simplest): Docker Desktop installed, one command to start the server, then the CLI talks to your local server. Your API keys stay on your machine. This is the setup most individual developers will use.

# Install the CLI
curl -sL https://plandex.ai/install.sh | bash
# (or install from the GitHub releases page if plandex.ai is down)

# Start the local server with Docker
docker run -p 8099:8099 plandexai/plandex-server

# Set up your API key (example: Anthropic)
export ANTHROPIC_API_KEY=sk-ant-...

# Initialize in your project directory
cd your-project
plandex new

Remote server mode: For teams or multi-user setups, Plandex server can run on any Linux host with Docker. You point the CLI at the server URL and manage user accounts through the API. This requires more setup — a PostgreSQL database, proper networking, and TLS if exposing externally — but is fully documented in the GitHub docs.

Windows is supported only through WSL. There is no native PowerShell or CMD support, and no indication that will change given the current maintenance state.

Model costs: what you actually spend

The software is free. Your API costs are the only ongoing expense.

Using the default model pack with Claude Sonnet 4.6 ($3 input / $15 output per million tokens), a typical mid-complexity task — “refactor this 800-line service to split concerns into three files” — runs 50,000 to 150,000 tokens depending on how many planning rounds it takes. That is $0.15 to $0.45 per task at Sonnet pricing, which is comparable to what you would spend on the same task in Aider.

If you switch the model pack to use OpenRouter’s free or low-cost tier models (Mistral, Llama 3, Qwen 2.5 Coder), you can run Plandex at effectively zero API cost with reduced quality. For organizations that cannot send code to cloud providers at all, the Ollama integration lets you run entirely local inference at zero per-token cost.

Context caching is used across Anthropic, OpenAI, and Google providers, which matters for long sessions where the same file content is referenced repeatedly. On Anthropic’s API, cache reads are 10% of the base input rate — a 200,000-token context re-read costs $0.06 instead of $0.60.

Where Plandex still beats the alternatives

Three specific scenarios where Plandex’s self-hosted approach is the right call in 2026:

Large monorepos with strict privacy requirements. If your codebase cannot touch third-party cloud infrastructure (financial services, healthcare, pre-launch IP), self-hosted Plandex with Ollama gives you a fully local agentic coding workflow. Aider can do this too, but Plandex’s tree-sitter project maps are better suited to very large codebases where you cannot fit the whole repo in context.

Long multi-step tasks requiring rollback granularity. The diff sandbox is genuinely useful when you are asking an agent to make many changes across many files and you want fine-grained control over what gets applied. Claude Code’s agentic mode applies changes as it goes; rolling back requires manual git commands. Plandex’s sandbox makes partial acceptance of a multi-file plan straightforward.

Teams who want model-routing by task role. Using a cheap model for summarization and a capable model for code generation, within a single session, is a real cost optimization that Plandex’s model pack system handles elegantly. Claude Code and Aider do not expose this level of per-role model control out of the box.

Where it falls short

Maintenance uncertainty. The last notable release (v2.2.1) shipped before the cloud shutdown announcement. There has been no major feature development since. The project relies on community contributions, and there is no team actively shipping new features. Bugs that surface now may wait weeks or months for a fix. For a primary daily driver, that is a meaningful risk.

Windows users are second-class. WSL works, but if your team includes Windows developers who are not already running WSL, the onboarding friction is real. Aider runs natively on Windows. Claude Code supports Windows. Plandex does not.

Setup complexity for local mode. Docker is a prerequisite, which rules out low-configuration environments (student machines, certain corporate lockdowns). A developer who just wants to run a CLI agent in five minutes will find Aider faster to start.

No active commercial support path. If something breaks in a self-hosted deployment, you are on your own — GitHub issues, community forums, and the MIT-licensed source. For teams that need a vendor-backed SLA, the alternatives are clear.

Plandex vs Aider vs Claude Code

	Plandex v2	Aider	Claude Code
Current status	Maintenance mode, self-hosted only	Actively developed, 44k+ stars	Actively developed, Anthropic-backed
Pricing	Free software + API costs	Free software + API costs	$20/mo Pro, $100/mo Max 5x
Setup	Docker + BYOK	pip install + BYOK	npm install -g @anthropic-ai/claude-code
Context window	2M tokens effective	Model-dependent	200K tokens (Claude)
Repo-scale indexing	20M tokens (tree-sitter)	Repo map (repomap algorithm)	File system access
Diff sandbox	Yes — changes quarantined until accepted	No — writes to files directly (dry-run flag available)	No — writes directly
Windows	WSL only	Native	Native
Local/offline	Yes (Ollama)	Yes (Ollama)	No (requires Anthropic API)
SWE-bench score	Not published	~51% (Sonnet 4.6)	87.6% (Opus 4.7)
Multi-model routing	Yes (model packs by role)	Yes (BYOK any model)	No (Claude models only)

Honest take

Plandex v2 is a well-designed tool in maintenance mode. The cloud is gone, the founding team has moved on, and the project is coasting on its MIT license and the goodwill of contributors. None of that makes the software bad — the technical fundamentals are solid — but it shapes how you should approach it.

Use it if: you need a fully local, privacy-first agentic coding workflow on Linux or Mac; you work on very large codebases where tree-sitter repo maps matter; or you specifically want the diff sandbox’s rollback granularity for complex multi-file tasks.

Skip it if: you want a tool that is actively improving; you are on Windows without WSL; you want a free option that you can set up in two minutes (use Aider); or you want the best raw agentic coding quality available (use Claude Code).

For the specific use case of large-codebase architectural refactors with privacy constraints, Plandex v2 self-hosted remains a defensible choice in 2026. For everything else, the active ecosystems of Aider and Claude Code have moved ahead.

If you are running a data engineering or DevOps stack and wondering about AI tooling, the AI Tools for Data Engineers article and AI Tools for DevOps cover how agents fit into those workflows specifically.

---

Sources

• Plandex GitHub Repository — plandex-ai/plandex (MIT, 15.4k stars)
• Plandex GitHub Releases — v2.2.1 changelog
• Plandex Cloud winding down announcement — GitHub README, October 2025
• Plandex self-hosting docs — quick-start guide
• OpenAI acquires Promptfoo — TechCrunch, March 2026
• Top CLI coding agents comparison 2026 — Pinggy
• AI coding agents comparison table 2026 — Terminal Trove
• Claude Sonnet 4.6 pricing — Anthropic platform docs
• Aider vs Claude Code comparison 2026 — Developers Digest
• 10 best AI coding agents 2026 — OpenAgents

Last updated May 23, 2026. Pricing and features change frequently; verify current state before deploying.