Vibing Agents — Guide to Vibe Coding Tools & AI Coding Agents (2026)

Pros: Comprehensive agentic suite — desktop app, IDE plugin, CLI, and mobile companion for remote session management; Quest Mode for autonomous multi-file execution; Experts Mode for parallel AI worker teams.

Cons: Ecosystem adoption still growing relative to larger corporate-backed platforms; free trial only for full feature set.

Memory / rules: Legacy refactoring patterns; Bug-focused memory.

Pros: Auto Free model router is the golden feature for pet projects, hobby builds, or scaffolding something serious without burning paid keys; open-source BYOK with transparency over prompts and context; automated migration path from Roo Code; 400+ models; official iOS and Android app to follow up on CLI/IDE sessions via /remote, start Cloud Agents, chat with KiloClaw, and monitor agents on the go; opt-in Kilo Memory keeps project-scoped session digests, environment facts, and corrections across CLI/TUI/VS Code sessions and worktrees.

Cons: Less integrated graphical experience than native editor forks like Cursor; mobile companion steers and supervises agents — not a full mobile IDE; Kilo Memory is still experimental (capture quality evolving; stored outside the repo, not git-shared).

Memory / rules: Open standards plus opt-in Kilo Memory (local project-scoped digests/corrections via /memory; shared across CLI, TUI, VS Code).

Mobile: App Store · Google Play

Pros: Provider-agnostic open-source agent (TUI, desktop, IDE extension); automatic LSP detection; free models plus BYOK across 75+ providers; OpenCode Go (~$10/mo, $5 first month) bundles curated open coding models with generous limits — usable in OpenCode or any agent via API key.

Cons: Smaller commercial support footprint than Cursor/Claude Code; Go is a curated low-cost lineup (not full frontier Claude/GPT) — Zen pay-as-you-go or BYOK for broader models.

Verified Aug 2026

Memory / rules: Project-level agent configuration; AGENTS.md via /init.

Pros: GLM frontier models (GLM-5.3, plus 5.2 / GLM-5-Turbo) via API and GLM Coding Plan; budget-friendly vs Claude/GPT tiers; powers the ZCode desktop ADE and third-party clients.

Cons: Not a prompt-to-app builder — models and billing only; occasional architectural drift on long multi-file tasks; desktop workflow lives in ZCode, not here.

Memory / rules: API context limits vary by plan.

Pros: 5-minute deployments; handles hosting/DB automatically.

Cons: Prompt-based generation limits architectural control; limited public market footprint.

Memory / rules: Built-in AI "Advisor" memory.

Pros: Fast web app generation from natural language with visual editing.

Cons: Vendor-hosted; export and portability vary; niche market footprint.

Memory / rules: Hosted project state.

Pros: Unified Agent Command Center with Kanban; Spaces for cross-agent context sharing; Devin Local (Rust rewrite of Cascade) reportedly ~30% more token-efficient; Agent Client Protocol for third-party agents.

Cons: Cascade local agent ended July 1, 2026 — migrate workflows to Devin Local; Devin Local still in preview with feature gaps; June 2026 rebrand from Windsurf.

Memory / rules: Spaces shared context; .windsurfrules legacy; Agent Client Protocol for third-party agents.

Pros: Manages agents in parallel; built-in Worktree support; native desktop apps on macOS and Windows (PowerShell or WSL2 sandbox).

Cons: Dependent on ChatGPT Plus/Pro (or API) subscriptions; Windows sandbox setup differs from macOS.

Memory / rules: Cascading memory (Global → Project → Folder priorities).

Pros: Advanced Plan Mode separates reasoning from execution; live prompt steering mid-task; LLM-agnostic — IDE, terminal, and CI; BYOK and Agent Skills.

Cons: Optimal use requires managing API keys or JetBrains AI credits; IDEA is the IDE host, not the agent itself.

Memory / rules: .junie/plans, custom guidelines, skills via /commands (CLI + IDE).

Pros: Extensible via Model Context Protocol; supports subagent recipes; runs locally for privacy.

Cons: CLI-only interface requires manual configuration and a learning curve.

Memory / rules: Local MCP-based session memory.

Pros: First-party CLI (`npm i -g cline`) for interactive terminal sessions or headless CI/automation — same agent core as the editor; highly autonomous in VS Code/JetBrains with terminal and browser research; ClinePass (~$10/mo) is strong open-weight subscription value — curated models with 2–5× usage vs API rate across CLI/IDE and via Cline API/SDK outside the editor.

Cons: High token burn on BYOK or Cline usage-billing without ClinePass; managing keys if you skip the subscription.

Verified Aug 2026

Memory / rules: .clinerules, persistent memory bank.

Pros: VS Code and JetBrains plugins that chat the repo and apply multi-file unified patches you approve; vector index of the whole codebase for file pick and Q&A; Chrome “Send to Codebuddy” to pull docs/blogs into context; built-in two-way voice (ElevenLabs TTS) so you can talk the diff; personal BYOK is listed as $0 for OpenAI keys.

Cons: Not CodeBuddy Studio (codebuddy.com) — this is a Canadian IDE plugin, not a spec-driven hosted studio; credit packs for non-BYOK models; JetBrains star-vs-incumbent claims are vendor marketing; no first-party CLI/AGENTS.md story vs Cline/Claude Code.

Verified Aug 2026

Memory / rules: Repo vector index; open-editor files up to ~128k tokens; patch/session state.

Pros: Pioneering open-source AI extension for VS Code and JetBrains; Apache 2.0 codebase on GitHub.

Cons: Acquired by Cursor; repo no longer actively maintained — try Kilo Code (plugin) or Cursor for a supported day-to-day setup.

Memory / rules: config.yaml assistants and context providers.

Pros: Direct VS Code fork retaining local data control without middleman routing; route any LLM with BYOK.

Cons: Requires BYOK setup; smaller team and ecosystem than Cursor.

Memory / rules: Local editor context; BYOK only.

Pros: Open-source AI editor with intelligent model router and Continue-style chat interfaces.

Cons: Dependent on external routing infrastructure; younger project than incumbents.

Memory / rules: PearAI Router + Continue-style config.

Pros: Agent-first platform with verifiable Artifacts deliverables; Manager view for parallel agent execution; desktop IDE and Antigravity CLI.

Cons: Replaced Gemini CLI and Code Assist IDE extensions for individuals (sunset completed June 18, 2026); Google ecosystem coupling; still maturing.

Memory / rules: Mission Control; shared agent harness with Antigravity CLI.

Pros: Goal-directed `/goal` — plans, implements, tests, and iterates in one loop; Vertically integrated desktop — file manager, terminal, and Git in one ADE; Mobile steering via WeChat, Feishu, or Telegram — nudge runs without the desktop; High guardrail tolerance — GLM-5.3 will attempt security-adjacent work others refuse; Multi-model BYOK — swap GLM defaults for Anthropic, DeepSeek, Kimi, or OpenAI keys.

Cons: Usage floors are now public — Lite 10k credits/week, Pro 6× Lite, Max 14× Lite, plus 5-hour buckets (Usage Policy; Lite up to ~87M GLM-5.3 tokens/week off-peak); Frequent Apple Silicon crashes — GitHub #51 documents EPIPE failures; Codex UI clone — the desktop is a near-exact visual copy of OpenAI Codex; China-based vendor — GLM-5.3 traffic routes through PRC-jurisdiction servers.

Verified Aug 2026

Memory / rules: Skills/playbooks; Goals task state; conversation checkpoints; MCP tool config.

Pros: Context Engine maps the repo semantically — claimed ~33% fewer tokens per task; Prism router — assigns work to frontier or open models per task; BYOK for LLM providers — enterprise teams can use their own keys; Multi-editor — native VS Code and JetBrains extensions; Top SWE-Bench Pro at 51.8% — strong vs competitors on that bench.

Cons: Credit pools since Oct 2025 — non-rolling monthly credits replace unlimited-feeling usage; Trial needs a card for 30,000-credit activation; Persistent HTTP gateway timeouts — connection errors are a recurring complaint; Slack and CMEK gated to Enterprise.

Memory / rules: Enterprise-grade context engine.

Pros: Rust-native GPU-accelerated editor; built-in collaboration; designed to run AI agents in parallel without UI degradation.

Cons: Smaller plugin ecosystem than established VS Code forks.

Memory / rules: Basic project structural context.

Pros: Dynamic workflows with parallel subagent processing; extremely high reasoning capability; terminal plus VS Code/JetBrains, Slack, web, and mobile.

Cons: Heavy sessions burn Claude Pro/Max quota or API spend fast; IDE/Slack/web surfaces still orbit the same Anthropic subscription.

Memory / rules: Robust context, progressive disclosure.

Pros: xAI terminal coding agent powered by Grok 4.6; plan mode with approve/comment before edits; skills + /skillify; plugins/marketplaces; MCP; parallel subagents with worktree support; Q&A for ambiguous tasks; headless mode for CI; AGENTS.md, hooks, memory, and sandboxed execution.

Cons: Tied to xAI/Grok stack (not BYOK multi-lab like OpenCode); young public CLI surface vs Claude Code/Codex; free trial availability and quotas can change.

Memory / rules: AGENTS.md; skills; session memory; plan artifacts.

Pros: Open-core "Cursor for circuit boards" — AI agent that edits real KiCad `.kicad_sch` / `.kicad_pcb` s-expressions, propagates changes across SPEC/BOM/docs, and verifies with `kicad-cli` ERC/DRC until clean; `copperhead create` runs an eight-stage gated pipeline from a brief; `copperhead do` iterates on existing repos; free CLI forever with BYOK / Codex / Cursor Agent / Claude Code logins; Cloud/Team add hosted runs + web viewer ($49/user/mo vendor list).

Cons: Hardware/EDA niche — not a software coding harness; early product (Phase 1 / pre-1.0 surface may move); needs Node 20+, KiCad ≥8 with `kicad-cli`, and a model backend; free CLI is KiCad-centric (Altium called out on Enterprise); catalog has not hands-on verified board spins.

Verified Sep 2026

Memory / rules: Markdown design memory (SPEC, BOM, DECISIONS, CHANGELOG, etc.); KiCad schematic/PCB as source of truth; git commits per stage; refuses dirty trees and unvalidated proposals.

Pros: Meta Superintelligence Labs terminal coding agent (beta) powered by Muse Spark 1.2 — multi-agent by default (parallel workers + background reviewers), append-only local event log for crash resume, cookbooks for worktrees/computer-use/GitHub bots; Muse Code subscriptions ($5/$15/$50/mo Everyday/High/Power Usage) bundle flat monthly CLI access with Spark, voice, web search, and multimodal limits — or pay-as-you-go tokens via Meta Model API.

Cons: Contributor tier (~$0.10 in / $0.002 cached / $0.20 out) is ~12–21× cheaper than Standard (~$1.25 / $0.15 / $4.25) because Meta trains on those prompts/completions and throttles throughput — treat as a governance choice, not just a line item; Standard keeps training off; subscription benefits vary by region; beta + Meta Model API lock-in; not a BYOK multi-lab harness like OpenCode/Prime Agent.

Verified Sep 2026

Memory / rules: Local append-only event log; multi-agent session/worktree state; Meta Model API config.

Pros: UI for managing CLI agents in parallel; no "terminal hell."

Cons: macOS exclusive; strictly a GUI wrapper.

Memory / rules: Wraps native CLI agent memory.

Pros: Generates local-first macOS desktop apps with deeper OS integration than typical web builders; public/private App Store for sharing.

Cons: macOS exclusive; vibe-coding closed ecosystem — hard to export a traditional codebase to VS Code.

Memory / rules: Abstracted application state and context memory.

Pros: Blazing fast visual feedback for frontend iteration.

Cons: Requires Mac-only local daemon.

Memory / rules: Visual state memory sync.

Pros: Incredible multi-agent routing (Oracle, Librarian).

Cons: Deprecated VS Code extension, alienated GUI users.

Memory / rules: Multi-agent context sharing.

Pros: Native MCP integration; autonomous SwiftUI visual QA.

Cons: Apple walled garden; Sequoia 15.6+ requirement.

Memory / rules: Native Apple context / MCP sync.

Pros: Robust Git integration with auto-generated commit messages; automatic linting and testing of generated code; repository map for large projects.

Cons: Strict command-line interface presents a learning curve; manual context limits.

Memory / rules: .aider.conf.yml, automated repo map.

Pros: Open-source autonomous agent with Docker sandbox; designed for large codebase migrations and vulnerability resolution.

Cons: Requires Docker sandbox setup; heavier than a simple plugin.

Memory / rules: Session and sandbox state in Docker.

Pros: ByteDance MIT SuperAgent harness (2.0 rewrite) that researches, codes, and creates via Docker AIO sandboxes (browser/shell/file/MCP/VS Code Server), skills, memory, and parallel subagents; multi-model (Doubao/DeepSeek/OpenAI/Gemini/etc.) plus Claude Code OAuth/integration; self-hosted app + harness SDK.

Cons: Ops-heavy (Docker RAM/CPU for long multi-agent runs); broader than a daily IDE coding agent — research/create workloads share the runtime; ByteDance/Volcengine model push in docs.

Verified Aug 2026

Memory / rules: Long/short-term memory; sandbox FS; skill modules; subagent session state.

Pros: Standalone Warp Agent CLI runs in Ghostty, iTerm, VS Code, and stock terminals — same multi-model agent as Warp Terminal; PTY mux for persistent sessions, directory switches, and remote SSH without a remote binary; agent can drive full-screen apps (sqlite, vim, htop); auto-routing across frontier and US-hosted open-weight models plus custom routers; native multi-agent orchestration and cloud-agent handoff; Warp Code multi-file edits; open-source core.

Cons: Agent inference needs a Warp subscription, ad-hoc credits, or BYOK/SuperGrok — not free unlimited; heavier than a plain shell; Agent CLI launched Aug 2026 so maturity vs Claude Code/Codex still proving out.

Verified Aug 2026

Memory / rules: Warp Drive sync; agent rules and project context; CLI session/orchestration state.

Pros: Spec-driven development — requirements, technical design, and task sequencing before code; property-based testing for edge cases.

Cons: Slower iterative velocity for simple edits vs direct prompt injection; AWS ecosystem coupling.

Memory / rules: Specs, steering files, and AWS service context.

Pros: Copilot on the web (github.com/copilot), CLI, and IDE plugins (VS Code, JetBrains, Xcode, Neovim, etc.); agents, spaces, and coding agent workflows; start and track Copilot coding agent sessions from GitHub Mobile (iOS and Android).

Cons: Tied to GitHub/Microsoft stack; agent features need specific plans; mobile is agent supervision, not a full IDE.

Memory / rules: GitHub repo and issue context.

Mobile: Copilot agents via GitHub Mobile — App Store · Google Play

Pros: AWS-native code assistant; infrastructure, security, and deployment aware.

Cons: Best value inside AWS ecosystem; weaker outside it.

Memory / rules: AWS service and codebase context.

Pros: Google enterprise plugin with 1M-token context for big monorepos; Standard/Enterprise licenses continue with latest Gemini models.

Cons: Free/individual IDE extensions and Gemini CLI stopped serving consumer tiers on June 18, 2026 — use Antigravity for personal workflows.

Memory / rules: Workspace and Google Cloud context.

Pros: AI across IDE and CLI — completion, explain, refactor, tests; zero-retention and on-prem for enterprises.

Cons: Assistance-focused; less full-agent hype than Cursor or Devin.

Memory / rules: Private codebase training options.

Pros: Ultra-fast tab completion with 1M+ token context window; team joined Cursor (Nov 2024).

Cons: Completion-only add-on — Cursor is the parent company's focus and ships this class of completion built in.

Memory / rules: Inline completion context only.

Pros: Multi-agent review (Qodo 2.0, Feb 2026) — specialized agents run in parallel on PRs; Auto-learning Rules — mines coding patterns from PR history; OSS self-host — PR-Agent (Apache 2.0) on Docker with your keys; Hosted model choice — Claude, OpenAI, and Gemini on paid tiers; 14-day unlimited trial — no card, full features before you commit.

Cons: BYOK is Enterprise-only — direct OpenAI/Anthropic keys are gated; Credit metering burns fast — Opus and Grok multipliers drain pools; Free tier cut and org-pooled — 30 PR reviews/month, down from 75; Cross-repo Context Engine is Enterprise-only.

Memory / rules: Test and PR context.

Pros: VS Code extension to spin up task-specific agents (review, onboarding) with your API keys.

Cons: BYOK setup; quality varies by model choice.

Memory / rules: Per-agent prompt templates.

Pros: Agentic coding product (formerly Auto Claude); growing autonomous dev feature set.

Cons: Early stage; limited public market footprint; thinner docs than incumbents.

Memory / rules: Project agent state.

Pros: Multi-worker agentic harness (research/coding/browser/docs/review) with multi-model routing; CLI plus agentic IDE and desktop/web surfaces; visible tool I/O.

Cons: Young SylphAI product; vendor-published SWE-Pro claims; desktop still Preview; Mac Apple Silicon focus for desktop.

Memory / rules: Session history; specialized worker routing (/agent, /model).

Pros: Open-source multi-platform coding agent; plugin ecosystem; spec-driven workflows and parallel agents; mainstream model providers.

Cons: VS Code extension and background agents still in active development; smaller footprint than Cursor/Claude Code.

Memory / rules: Plugins; extensible slash commands and output types.

Pros: TRAE IDE positioned as an AI coding engineer plus TRAE Work as a separate professional AI work assistant (web/desktop).

Cons: Marketing-heavy public pages; little transparent pricing/AGENTS.md/MCP detail on main landings.

Memory / rules: IDE and Work session context.

Pros: Nucleus multi-surface ecosystem (IDE, GitHub, CLI, cloud agents); can wire existing Claude Code / Codex / Antigravity subscriptions into one workspace.

Cons: Early preview footprint; marketing ecosystem is noisy; do not confuse with Teramind employee-monitoring.

Memory / rules: IDE/CLI/cloud agent session state; git review flows.

Pros: Agentic SDLC across plan → generate → review → automate; deep Jira/Bitbucket/GitHub via Teamwork Graph; VS Code + CLI with parallel background tasks.

Cons: Strong Atlassian lock-in; enterprise sales motion; weak fit outside Jira-centric teams.

Memory / rules: Jira/Bitbucket/GitHub context via Teamwork Graph.

Pros: DeepSeek-native terminal agent (MIT); cache-first sessions claim high prefix-cache hits and lower input cost; MCP; plan mode + sandbox; single Go binary; subagents (explore/research/review).

Cons: DeepSeek-optimized — less any-model than Crush/OpenCode; young brand.

Memory / rules: Append-only session aligned to DeepSeek prefix cache; plan mode permissions.

Pros: Open-source Claude Code–class terminal agent (Apache-2.0); Auto-Memory/Skills/SubAgents/Teams/MCP; multi-protocol providers (Qwen, OpenAI, Anthropic, Gemini, local); IDE plugins, desktop app, daemon, IM bots.

Cons: Originally Gemini CLI fork (diverged); Alibaba Model Studio residency considerations; large fast-moving surface area.

Memory / rules: Auto-Memory, Agent Teams, hooks, project instructions.

Pros: Self-evolving code agent with deep codebase indexing; agent teams with crash recovery; auto-mode in git worktrees; VS Code/Zed/JetBrains + CLI.

Cons: Early OSS metrics; BYOK/pricing details thin on product landings.

Memory / rules: Project index; agent-team state.

Pros: Enterprise AI coding partner with Bob Shell for CI; subagents; literate coding; Bobalytics; packages for Java/mainframe/IBM i modernization; Red Hat/Instana hooks.

Cons: Enterprise sales/governance stack; not indie BYOK; IBM ecosystem coupling.

Memory / rules: Enterprise codebase and SDLC analytics context.

Pros: Huawei Cloud AI R&D agent/IDE with expert skills/tools; large-codebase comprehension claims; JetBrains plugin surface.

Cons: Huawei Cloud residency/ecosystem lock-in; English docs/UX uneven; regional beta.

Memory / rules: CodeArts platform and IDE session context.

Pros: CLI coding agent with taste learning from accept/reject; MCP/plugins; skills; open-model pricing deals; shareable sessions.

Cons: Early startup; marketing-heavy; verify long-term pricing after seed-era promos.

Memory / rules: Persistent /memory; taste push/pull for teams.

Pros: Data-native coding agent for Snowflake engineering/analytics/AI workflows; Desktop GA plus CLI, Snowsight, and IDE extensions; Snowflake trust/governance story.

Cons: Requires Snowflake account/ecosystem; not a general-purpose repo agent for non-data stacks.

Memory / rules: Snowflake warehouses/notebooks/workspace context.

Pros: Polished Charm TUI coding agent; multi-model mid-session switch; MCP; LSP-enhanced context; wide OS packaging; large GitHub traction.

Cons: Terminal-only; you manage model keys/quality.

Memory / rules: Session contexts; LSP-enhanced project context.

Pros: ZSH-integrated coding harness (`:`); claims #1 TermBench 2.0; multi-model mix mid-session; sub-agents (Forge/Muse/Sage); strong OSS community metrics.

Cons: Vendor TermBench leadership is self-promoted — treat carefully; ZSH-centric.

Memory / rules: Bounded multi-agent session context.

Pros: Multi-surface Nous agent across Telegram/Discord/Slack/WhatsApp/Signal/Email/CLI with shared memory; scheduling; subagents; web browse; Docker/SSH/Modal-class sandboxes.

Cons: Broader personal/ops agent than a pure coding IDE; coding-specific AGENTS.md story unclear on landing.

Memory / rules: Cross-surface persistent memory.

Pros: Alibaba Cloud AI coding assistant used widely inside Alibaba; Individual Edition quick start; enterprise dedicated edition.

Cons: Alibaba Cloud coupling / China residency; less terminal-agent than Qwen Code.

Memory / rules: IDE and Alibaba Cloud project context.

Pros: Minimal, hackable coding harness with AGENTS.md/SYSTEM.md, skills, mid-session model switch, tree session history, and package extensions; BYOK across many providers.

Cons: Intentionally fewer batteries (no built-in subagents/plan by default) — you assemble what you need.

Memory / rules: AGENTS.md + SYSTEM.md + compaction + skills + prompt templates.

Pros: Batteries-included MIT fork of Pi — sessions, subagents, slash commands, 40+ providers; in-process Rust tools (ripgrep, glob, find, bash) so Windows runs native with no WSL; LSP and DAP wired in (rename, format, debug) instead of shelling out; hash-anchored edits plus persistent Python/Bun kernels that can call agent tools; TUI, one-shot `-p`, RPC/ACP, and a Node SDK (`curl | sh`, brew, bun).

Cons: Easy to mix with pi.dev — this is Can Bölük’s oh-my-pi fork, not Mario Zechner’s tiny harness; benchmaxxed landing-page claims; fast npm/version train; heavier than stock Pi if you wanted the minimal agent.

Verified Aug 2026

Memory / rules: Inherited rules/skills/MCP from Claude/Cursor/Gemini/Codex/etc. on first run; omp session + config.

Pros: MIT open-source self-improving harness (Prime Intellect) built on Recursive Language Model + Continual Harness — persistent IPython as the model tool, `rlm(...)` subagents, `/refine` evidence-backed harness updates with rollback, daemon detach/reattach, goals/heartbeats/schedules, executable Python skills; subscriptions + multi-provider BYOK including self-hosted; TUI forked from pi.

Cons: Young public release (Aug 2026); IPython-centric trust model — model-generated Python/commands run with your user permissions (not a security sandbox); research/eval-shaped surface vs polished daily IDE agents; ARC-AGI-style claims are harness+model dependent.

Verified Aug 2026

Memory / rules: Continual Harness supplemental prompts/memories/skills/subagent specs; session + IPython state; /refine snapshots.

Pros: Official DeepSeek MIT harness on Cordis — every capability (model, tools, skills, session log, sandbox, loop, UI) is a swappable plugin; local Web UI (`npx @deepseek-ai/dsh web`) plus headless/ACP/JSON-RPC; Standard/Code/Minimal/Creator modes; append-only session log for resume/fork/replay; first-party AGENTS.md and skills; Claude Code/Codex hook bridges.

Cons: Developer preview with promised breaking changes and no on-disk format compatibility; pin the 0.1.0-rc npm train (`latest` has pointed at a stale RC); default path is DeepSeek API not OpenCode-class multi-lab BYOK; no hosted cloud agents or GitHub PR product vs Claude Code/Codex; PRC vendor/API residency; V4 peak/off-peak price hike (from 2026-08-16) hits default inference.

Verified Aug 2026

Memory / rules: Append-only session event log (fork/resume/replay); cordis.yml / profile patches; skills catalog; plan/goals/subagent state; optional MCP client (no server enabled by default).

Pros: Unifies browser + IDE + agents locally; context rasterization claims large token savings; harness for Claude Code/Codex/Gemini/OpenRouter you already pay for; local data.

Cons: Young builder-workspace category; Mac/Windows desktop only; not a classic VS Code fork.

Memory / rules: Local workspace + underlying agent memory.

Pros: Multi-agent coding platform: Blackbox IDE, VS Code agent, CLI, and API; run Claude Code, Codex, Gemini, Goose, OpenCode and more through one layer with a judge that picks the best result; encrypted inference path with CMK / zero retention; MCP and Skills.

Cons: Vendor lock-in to Blackbox’s gateway and plans; marketing-heavy claims (speed/price benches, agent counts); encrypted inference substrate is not a reason to shelf it under Inference providers.

Memory / rules: Project index; Blackbox Skills; multi-agent run state.

Pros: Spec-driven coding agent that generates code alongside machine-checkable proofs (TypeScript, Java, Rust); full CLI workflow or MCP verify-only while staying in Cursor/Claude Code/Codex; Apache-2.0.

Cons: Early Astrio project (small public footprint); language coverage still limited; binary release required for CLI install.

Memory / rules: Spec/proof artifacts; verify reports via MCP.

Pros: Prompt-to-PR CLI agent optimized for open-source models; /ferment plan-once handoff with milestone self-eval; automatic multi-model routing (plan vs execute); one-command migrate of Claude Code/OpenCode MCP + skills; spend console with per-user/team/API-key budgets; /teleport remote workspaces.

Cons: Young product (Cast.ai team); OSS-model-first — frontier proprietary quality still via evaluator choice; Studio/remote agents still rolling out; not a VS Code fork.

Memory / rules: Migrated Claude Code/OpenCode skills + MCP; ferment milestone state; console usage tags.

Pros: Persistent repo memory in `.memcode` (subsystems, past work, failed approaches, corrections) so sessions start oriented; honors MEMCODE.md / AGENTS.md / CLAUDE.md; Agent Skills, MCP, hooks, resident LSP; `/plan` with parallel scouts + cross-model review; automatic cheap→strong model routing with fallbacks; BYOK or self-hostable MIT gateway (one Go binary).

Cons: Brand-new public release (tiny GitHub footprint as of Aug 2026); marketing also sells hosted DataHub chat, scheduled agents, and a website builder — the coding CLI is the Agents-shelf product; maturity vs Claude Code / OpenCode still unproven.

Verified Aug 2026

Memory / rules: `.memcode` durable repo memory + session history/lessons; MEMCODE.md / AGENTS.md / CLAUDE.md; compaction that respects model windows.

Pros: Tiny ~6.4 MiB Zig coding agent with ~10µs cold start and single-digit MB baseline — built to embed in sandboxes and pack many local instances; shell-like CLI (not a heavy TUI) plus ACP for editors, `fx ask` headless, and an experimental WASM SDK; first-class AGENTS.md (global, workspace, and target-scoped), SKILL.md discovery across Claude/Codex/OpenCode/agents dirs, MCP, and session-backed subagents; context-efficient prompt/tools for cheaper TTFT; permission modes with a command sandbox.

Cons: Officially experimental (v0.0.x) with frequent breaking changes; auth and the model catalog currently go through hosted Vercel AI Gateway (login or gateway key), not OpenCode-class keys you paste for every lab; native install is macOS/Linux only; WASM embed drops native MCP, skills, subagents, and OS sandbox vs the local CLI.

Verified Aug 2026

Memory / rules: ~/.fx/AGENTS.md plus workspace and target-scoped AGENTS.md; skills catalog; MCP; saved sessions with resume/compaction; permission/sandbox grants.

Pros: Google-hosted cloud agent for async GitHub issue/PR work — spins a Cloud VM, proposes a plan, generates a diff, and opens a PR after you approve each step; Gemini-backed reasoning; free tier advertised at 15 tasks/day and 3 concurrent runs (vendor marketing).

Cons: Cloud-only — no on-machine or air-gapped execution; task caps on free tier; Google account and Gemini stack lock-in; catalog has not hands-on verified runs.

Verified Sep 2026

Memory / rules: GitHub repo/issue context; Jules cloud VM session and PR artifacts.

Pros: Moonshot Kimi Code CLI — terminal coding agent with shell mode, VS Code/ACP integration, and open-source codebase (MoonshotAI/kimi-code).

Cons: Moonshot-tied UX and model/plan ecosystem coupling; catalog has not hands-on verified daily use.

Verified Sep 2026

Memory / rules: CLI session state; VS Code/ACP agent config; shell execution context.

Pros: Local OSS Rust terminal coding agent with TUI — bring your own models via OpenAI-compatible endpoints; VS Code extension path; lightweight compared to monolithic harnesses.

Cons: Young OSS footprint vs Aider/OpenCode; catalog has not hands-on verified; TUI-only primary surface may not suit GUI-first teams.

Verified Sep 2026

Memory / rules: Local TUI session; BYOK model config; optional IDE plugin context.

Pros: ~100-line simple agent harness for GitHub issues and CLI workflows; MIT license; vendor claims >74% SWE-bench verified performance — lightweight alternative to the full SWE-agent monorepo.

Cons: Research/harness niche vs daily IDE agents; not the full SWE-agent research stack; catalog has not hands-on verified bench claims.

Verified Sep 2026

Memory / rules: Issue/CLI session state; minimal harness config.

Pros: Local open-model computer-use coding agent — runs code on your machine with natural-language control; OSS community; supports many local and API models for privacy-conscious workflows.

Cons: Computer-use safety surface requires careful permissioning; not a hosted PR factory; catalog has not hands-on verified on latest release.

Verified Sep 2026

Memory / rules: Local session history; model and permission config.

Pros: Xiaomi MiMo Code — OSS terminal coding agent with multi-provider TUI and desktop paths on the MiMo stack; BYOK across providers.

Cons: Xiaomi/MiMo ecosystem coupling; Western docs and community thinner than Claude Code/OpenCode; catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: TUI session state; multi-provider API keys.

Pros: BYOK pricing — use your Claude API keys with no per-token markup from HumanLayer; Opinionated QRSPI — Questions, Research, Design, Structure, Plan, Implement; Parallel sessions — run multiple Claude Code instances at once; Free Starter for small teams — up to 3 members on the full IDE; Keyboard-first context engineering — session forking and QRSPI artifacts.

Cons: Desktop IDE is still waitlist-heavy as of mid-2026; Claude Code lock-in — no GPT or Gemini fallback; Early stability issues — WSL users report daemon flush timeouts; QRSPI is heavyweight — six phases add overhead for small edits.

Memory / rules: Task-scoped artifacts (research.md, design.md, plan.md); QRSPI phase checkpoints; OSS RPI slash commands in humanlayer/humanlayer.

Pros: Augment's intent layer for routing complex engineering goals across agents and repos.

Cons: Enterprise pricing; tied to Augment's context stack.

Memory / rules: Intent specs and enterprise context engine.

Pros: Built-in event-driven automation via Maestro Cue; cross-platform multi-agent coordination.

Cons: Advanced automation pipelines require complex configuration.

Memory / rules: Multi-agent task graph and run history.

Pros: Kanban board for parallel vibe-coding and agent tasks; great visibility into WIP.

Cons: Hosted product is sunsetting; continues as OSS/community (`npx vibe-kanban`); still orchestration only — you need underlying agents.

Memory / rules: Board state and agent run metadata.

Pros: Parallel Claude Code, Codex, and Cursor agents in isolated Git workspaces — local Mac plus Conductor Cloud agents in microVM sandboxes that keep running after you close the app; multiplayer workspace links so teammates can follow and prompt agents together; Conductor API (beta) to create cloud workspaces, send prompts, and wire bots/OpenClaw; Free tier still covers local parallel agents with BYOK/existing subs.

Cons: Cloud agents, Multiplayer, and API require Pro ($50/mo) or Teams — Free stays local-only; Cloud sessions store chat on Conductor servers (unlike local privacy); cloud compute is bundled now but usage-based pricing is planned; mobile companion still coming soon, and local workspaces remain Mac-first.

Verified Aug 2026

Memory / rules: Local worktree/workspace state; Cloud session transcripts; org multiplayer follow state.

Pros: AGPL local desktop ADE that runs the real `claude` / `codex` / `agy` / `copilot` / `grok` / `opencode` (or any PTY CLI) in parallel git worktrees — no Termic backend; optional macOS Seatbelt + network allowlist; Spotlight sync into main checkout without committing; broadcast, Ralph-style loops, AI review of another agent’s diff, Git staging, `.termic.yaml`, and a `termic` CLI; macOS Homebrew/DMG plus signed Linux AppImage.

Cons: Orchestration only — you still install and pay the underlying CLIs; AGPL-3.0; sandbox is macOS-only (Linux AppImage unsandboxed; Windows is source-build, no prebuilt); no hosted cloud agents or mobile companion vs Conductor Pro / T3 / Orca; young public footprint vs commercial Conductor.

Verified Aug 2026

Memory / rules: Local projects/tasks/worktrees; `.termic.yaml` (scripts, preview, sandbox allowlist); wraps underlying CLI AGENTS.md/skills; optional Seatbelt + hostname allowlist.

Pros: Parallel execution of multiple CLI agents across isolated Git worktrees.

Cons: High system resource utilization during heavy parallel execution.

Memory / rules: Worktree and session state per agent.

Pros: Git worktree isolation helps prevent merge conflicts; parallel CLI agents with SSH remote execution and Linear/GH/Jira sync.

Cons: Desktop app needs a local install; Bring Your Own Infra / SSH remotes — not model-key BYOK.

Memory / rules: Local SQLite state; wraps underlying CLI agent memory.

Pros: Open-source Agent Development Environment for parallel Claude Code, Codex, OpenCode, Cursor CLI, and other agent CLIs in isolated git worktrees; Ghostty-class terminals, embedded Chromium/Design Mode, SSH remotes, iOS/Android companion.

Cons: Orchestration ADE only — bring your own agent subscriptions; assumes you read diffs and care about git hygiene.

Memory / rules: Worktree and agent-session state; wraps underlying CLI agent memory.

Pros: Open-source (MIT) control plane for Claude Code, Codex, Cursor, Grok Build, and OpenCode — BYO existing subscriptions, no token resale; Electron desktop + web (app.t3.codes) + iOS/Android remote; one-button commit/push/PR with per-thread branches and inline diffs; `npx t3@latest` try path; forkable UI and agent wiring.

Cons: Very early — expect bugs; orchestration only (install and auth at least one provider CLI first); large open-issue backlog; Electron desktop vs lighter native shells.

Verified Aug 2026

Memory / rules: Per-agent thread/branch state; wraps underlying harness memory (Claude/Codex/Cursor/Grok/OpenCode).

Mobile: Remote control of agents on your machine — App Store · Google Play

Pros: BYOK on all plans including Free — OpenAI and Anthropic calls bypass bundled credits; Git worktree isolation per task — parallel agents without colliding branches; Spec-driven workflow — structured planning instead of freestyle chat; Multi-model orchestration — different models for plan vs implement; Full-repo indexing — structure and dependencies across large codebases.

Cons: BYOK still needs a paid seat — Pro through Pro Max run about $40–$175/mo; JetBrains white screen on 2025.1+ — JCEF rendering can break chat; Large-repo indexing is slow on first semantic pass; Credit multipliers — Opus 4.6/4.7 billed at 5× per request.

Memory / rules: Enterprise codebase indexing; Zenflow agent run state.

Pros: Open-source (AGPL) parallel coding agents in isolated workspaces; multi-model; browser + desktop UI from Coder Technologies.

Cons: AGPL; orchestration layer — still need underlying coding agents/models.

Memory / rules: Isolated workspace and agent run state.

Pros: AI workspace where agents use real tools (apps/flows/workers); multi-model one API; belt CLI installs evolving skills across Claude Code/Cursor/runtimes; durable agent state that compounds across sessions.

Cons: Workspace BYOK is not an OpenRouter-class inference catalog — and not a drop-in Cursor/Claude Code replacement for git repos alone.

Memory / rules: Platform skills, knowledge stack, durable agent/session state.

Pros: Real-time collaboration via chat relay without shared filesystems; each participant's agent runs locally; debounced loop prevention.

Cons: macOS and Linux only; relies on terminal multiplexing (tmux).

Memory / rules: Per-room chat relay; local agent MCP config.

Pros: Predictable flat pricing; routes to optimized open-weight models based on monthly evaluations.

Cons: Legacy desktop GUI is no longer in active development.

Memory / rules: D3 Engine workspace memory.

Pros: Spotify’s macOS ADE for parallel Claude Code / Codex / Gemini sessions with persistent terminals and Git worktree isolation; optional Spotify Portal link injects Software Catalog + Workspace wiki/records/members via MCP so agents start with org context; launch from catalog entities; upload session transcripts for teammate continuity; local skills/rules without replacing native agent CLIs.

Cons: Beta + invite; macOS only; wraps Claude Code/Codex/Gemini (not a BYOK multi-lab harness like OpenCode); Portal institutional memory needs a Spotify Portal instance; transcript upload does not redact secrets — manual review required; not a solo curl-install OSS CLI.

Verified Aug 2026

Memory / rules: Local skills/rules + session history; optional Portal Workspace MCP (wiki, catalog entities, prior sessions) and shared transcript uploads.

Pros: Desktop ADE that launches the CLIs you already use (Claude Code, Codex, Gemini CLI, OpenCode) in visible terminal panes as a team; Matcha visual QA agents turn plain-English web/mobile journeys into self-healing tests on PR previews; monitoring agents watch production (errors, feedback, sessions) and open repair PRs; optional cloud background tasks from a synced board; local-first — code stays on your machine unless you turn cloud on.

Cons: Not a coding agent SKU — you still install and auth Claude Code/Codex/Gemini/OpenCode; Cursor is unsupported; first-run requires a TeaHouse account; pricing not clearly published on the public landing; MCP is a local session endpoint for launched panes, not a public Toolkit MCP.

Memory / rules: Tasks, plans, session logs, diffs, QA runs, and TeaHouse board state; launched CLIs keep their own AGENTS.md/skills/permissions; local MCP/API for pane tools.

Pros: Always-on isolated cloud computers for Claude Code, Codex, OpenCode, and Pi — start in the app or iMessage, continue in the browser or SSH with files and sessions intact; hibernates when idle; Firecracker sandbox API; `omg` CLI deploys an existing app to `*.omgs.app`; hosted MCP for service status and existing deploy management; self-host via the same stack (ex-lfg).

Cons: Not a coding-agent SKU — you still bring Claude/Codex/OpenCode/Pi; prompt-to-app builder is retired (docs.omg.dev still describes the old vibe product — ignore that); young OSS footprint; public hosted pricing thin on the landing; MCP does not create or steer app-building runs.

Memory / rules: Durable cloud-computer disk + agent sessions across hibernate/resume; sandbox snapshots; deploy dashboard at app.omg.dev.

Pros: Web + Electron control plane to run Claude Code, Codex, Gemini, Goose, Pi, and other coding-agent CLIs as isolated background processes in Daytona sandboxes wired to GitHub; switch agents mid-run, branch chats, merge conflict resolution, and scheduled agents; `npx background-agents` desktop launcher loads backgrounder.dev; OSS building blocks (Apache-2.0) for self-hosting the same stack.

Cons: Orchestration only — you still bring and pay for underlying agent CLIs; young product with JS-heavy docs that are thin for crawlers; hard dependency on Daytona sandboxes; not Cursor Background Agents (Cursor Cloud) or a Devin-class vibe builder; catalog has not hands-on verified runs.

Verified Sep 2026

Memory / rules: Chat threads, branched conversations, scheduled agent runs, and Daytona sandbox state synced to GitHub repos; wraps underlying CLI harness memory.

Pros: Open-source human+agent project-management and orchestration layer — assign issues to coding agents like teammates with enqueue/claim/start/complete lifecycle, comments, and blocker flags; reusable SKILL.md skill library shared across agents; unified runtimes panel for local daemon plus optional hosted cloud with usage monitoring; auto-detects ~26 supported agent CLIs (Claude Code, Codex, Gemini CLI, Cursor, OpenCode, OpenClaw, Pi, and others); web, desktop, and `multica setup` CLI; agent execution stays on user-controlled runtimes — Multica coordinates state, not models.

Cons: Orchestration only — you bring and pay for underlying agent CLIs/models; young product (high GitHub visibility but catalog has not hands-on verified runs); Multica License restricts third-party hosted SaaS beyond plain Apache-2.0 (internal self-host OK; public hosted instances need a commercial license); not Cursor Background Agents, Backgrounder (Daytona sandboxes), Devin-class vibe builders, or Linear/Jira without agent execution.

Verified Sep 2026

Memory / rules: Issues/board, activity feed, reusable skill library, and runtime/daemon state; wraps underlying CLI harness memory.

Pros: MIT open-source desktop + VS Code extension + CLI orchestration workspace — organize work into Tasks with Chat or Terminal agents, panels (files, git diff, artifacts: specs/tickets/stories/reviews), git worktrees, history, and sharing/comments; BYOA for Claude Code, Codex, Cursor, and OpenCode without Traycer inference metering on the $0 plan; agent-to-agent delegation (parent/child agents); built-in workflow skills (plan/execute/review); multiplayer workspaces and cross-device sync on paid tiers.

Cons: Orchestration layer still needs underlying agent subscriptions; dual product surface (Desktop app vs older IDE-extension docs) can confuse onboarding; catalog has not hands-on verified runs; homepage marketing is heavy; optional Traycer inference subscription is separate from BYOA.

Verified Sep 2026

Memory / rules: Tasks, artifacts (specs/tickets/stories/reviews), decision history, shared task filesystem/context, worktree/git state; wraps underlying agent harness memory.

Pros: MIT open-source agent harness (server + chat UI + TypeScript SDK) with BYOK models, MCP connectors, git-backed SKILL.md, sandbox-as-a-tool, subagents, HITL approvals, and context compaction; local `npx @truefoundry/trueforge` or self-host via Docker/Helm; positioned as a Claude Managed Agents alternative without Anthropic lock-in.

Cons: Brand-new OSS (public repo July 2026, launch coverage Aug 2026); Enterprise-Bench cost claims are vendor-run (14 tasks, n=3) — not SWE-bench; local mode has no login and is localhost-only; optional TrueFoundry AI Gateway is a commercial funnel, not required; not a git-repo coding CLI like Cursor/Claude Code/ForgeCode.

Verified Aug 2026

Memory / rules: Persisted sessions; agent library specs; MCP connector credentials; sandbox artifacts; compaction summaries.

Pros: Factories-as-code (`factory.yaml`) for fleets of coding agents across the SDLC — any harness (Warp, Claude Code, Codex, Cursor), any model, Warp cloud or self-hosted VPC; API/CLI/SDK/MCP; evals and observer agents that PR factory config; human checkpoints from Slack/Linear/GitHub.

Cons: Closed early access with usage-based pricing (qualifying orgs cited $10k factory credits) — not a consumer free SKU; orchestration only (you still bring agent harnesses/models); vendor SDLC-automation stats; easy to confuse with Factory.ai Droid agents and with Warp Terminal/Agent CLI.

Verified Aug 2026

Memory / rules: factory.yaml plus agent/automation markdown; run history, evals, and factory-config PRs; wraps underlying harness memory.

Pros: Code channels inside Slack where you mention Claude, Devin, GitHub Copilot, or Vercel and the whole team sees diffs, live previews, and approvals; inherits existing Slack permissions; available on any Slack plan; channels archive into a searchable audit log.

Cons: Orchestration surface only — you still need access to each partner agent; ChatGPT listed as coming soon at launch; not a local repo CLI/IDE; work still leaves Slack for hard coding in terminals and IDEs.

Verified Aug 2026

Memory / rules: Slack code-channel transcripts, diffs, canvases, and archived audit logs; wraps partner-agent context.

Pros: YC MIT multiplayer agent harness for a whole startup: each person and Slack/web room gets scoped memory, files, keychain, crons, and a durable sandbox; swap Pi, OpenCode, Codex, or Claude Code on the same core; deploy in your own Fly or AWS account (`npx @yc-software/qm` init); shared skills, inbound webhooks, and internal web apps.

Cons: Early experimental software (their SECURITY.md); you operate Postgres, identity, and the cloud account — not a hosted ADE; orchestration only (bring harness subscriptions); Slack Code is the no-ops alternative if you only want partner agents inside Slack.

Verified Aug 2026

Memory / rules: Per-scope memory, files, keychain, permissions, crons, and sandbox; org skills (grant + git packs); Postgres session history; wraps Pi/OpenCode/Codex/Claude Code.

Pros: OSS TUI orchestrator for running multiple Claude Code (and similar) agent sessions in parallel from the terminal — tmux-style visibility with lightweight local control.

Cons: AGPL-3.0 license; orchestration only — bring your own Claude Code subscriptions; terminal/TUI-first vs desktop ADEs; catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: Local tmux/session panes; wraps underlying CLI agent memory.

Pros: macOS desktop orchestrator for parallel coding-agent sessions — manages multiple agent CLIs/workspaces with local-first control; OSS from Manaflow.

Cons: macOS-only desktop; orchestration only — bring underlying agent CLIs; young product vs Conductor/Termic; catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: Local workspace/session state; wraps underlying CLI harness memory.

Pros: OSS orchestrator spanning desktop, mobile, web, and CLI — coordinate coding agents across surfaces with local-first options and optional cloud sync.

Cons: Orchestration only — bring agent harnesses; multi-surface ambition means thinner docs per platform; catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: Cross-device session/board state; wraps underlying agent CLI memory.

Pros: OSS desktop Agent Development Environment for parallel coding-agent workflows on desktop and mobile companion surfaces.

Cons: Orchestration ADE only — install and pay underlying CLIs; young footprint vs Orca/Conductor; catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: ADE workspace and agent-session state; wraps underlying CLI memory.

Pros: Imbue OSS desktop orchestrator for shaping and supervising multiple coding-agent sessions from a unified local workspace.

Cons: Orchestration only — bring agent CLIs; Imbue product footprint still maturing; catalog has not hands-on verified; do not confuse with sculptor.ai.

Verified Sep 2026

Memory / rules: Local workspace/session orchestration state; wraps underlying agent CLIs.

Pros: GitKraken Kepler preview ADE — desktop (and mobile companion) orchestration over coding agents in the GitKraken ecosystem with Git-native workflows.

Cons: Preview/early access from GitKraken — features and pricing still moving; closed-source; orchestration SKU not a BYOK multi-lab CLI; catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: GitKraken workspace and Kepler agent-session state.

Pros: OSS CLI orchestrator for coordinating multiple coding-agent workers — local-first control plane with docs at docs.gastownhall.ai.

Cons: Orchestration only — bring agent CLIs; young OSS vs Conductor/Claude Squad; NOT gastown.ai (unrelated domain for sale); catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: CLI orchestration state; wraps underlying agent harness memory.

Pros: Integrates services like Stripe and Postgres; automates refactoring from natural language.

Cons: Abstracted architecture limits granular engineering control.

Memory / rules: Abstracted application context.

Pros: Best for UI components; instant Vercel deployment.

Cons: Prompt-to-ship Vercel apps (UI-first); weaker as a local repo agent than Cursor/Claude Code.

Memory / rules: Component and UI state memory.

Pros: Syncs with Supabase automatically; visual editor.

Cons: Vendor lock-in; pricing scales up quickly.

Memory / rules: Supabase schema sync memory.

Pros: Enterprise-grade backend infrastructure in the browser; automatic model routing.

Cons: Browser execution can throttle on large monorepos.

Memory / rules: Ephemeral browser dev environment.

Pros: Prompt-to-app Studio with dual cloud agents — Conductor (AI PM) plans acceptance criteria, Virtuoso (AI engineer) builds/tests in real Docker containers rather than a browser sandbox; one-click Cloudflare edge deploy; creator marketplace with ~70% revenue share; Lite from $5/mo.

Cons: Cloud credit burn and vendor lock-in; marketing-heavy completion claims; Studio API still private beta; not a repo-local CLI/IDE agent.

Verified Aug 2026

Memory / rules: Conductor acceptance criteria + Virtuoso Docker session/project state.

Pros: Open-source Bolt-class browser/Electron builder with BYOK across 19+ LLM providers (OpenRouter, Ollama, Bedrock, etc.); MCP; Git/GitHub; WebContainer live preview; one-click deploy to Vercel/Netlify/GitHub Pages; Supabase hooks.

Cons: Self-host/ops burden vs Bolt.new; browser sandbox still weak on huge monorepos; community docs (stackblitz-labs) — not the commercial Bolt.new SKU.

Memory / rules: Local/self-hosted project + .env provider keys; MCP config.

Pros: Local-first open-source desktop AI app builder (macOS/Windows) positioned as a Lovable/v0/Bolt alternative you run on your machine; BYOK (OpenAI, Anthropic, Gemini, Ollama, LM Studio); 1.11 ships preview test recording plus Auto Sidekick (GPT 5.6 Sol supervising cheaper Luna implementation); real exportable code; GitHub/Vercel or bring-your-own cloud; MCP client; Supabase; Apache 2.0 core.

Cons: Auto Sidekick is a Dyad-routed two-model loop (not a reason to skip BYOK, but it is not your own keys); Pro features under FSL in src/pro (not fully Apache); not a Cursor-class coding agent for existing monorepos.

Verified Aug 2026

Memory / rules: Local project on disk + MCP servers; per-chat sticky model and per-model effort; import/export standard code (no proprietary project format).

Pros: Self-contained browser ecosystem with Agent Free Mode (GPT-5.6 Luna) so everyday chat and tasks skip credit burn on Core/Pro; handles bug patching during builds; official iOS and Android apps for Agent, editing, and publishing.

Cons: Platform lock-in; Free Mode caps reset every 5 hours and Agent may push you to credit-burning Power/Max for complex builds; native mobile app builds still need the web Project Editor.

Verified Aug 2026

Memory / rules: Replit workspace and deployment context; Free/Power/Max agent modes.

Mobile: App Store · Google Play

Pros: Cognition's autonomous cloud engineer; plans, codes, and debugs in a remote environment.

Cons: Usage beyond plan quota bills on-demand; separate SKU from Devin Desktop IDE.

Memory / rules: Cloud session state; integrates with Devin Desktop command center.

Pros: Advanced long-horizon task planning; persistent file system management; desktop and mobile apps for async agent tasks.

Cons: Cloud-first — desktop extends rather than replaces the hosted agent; Free Agent Mode is Manus 1.6 Lite only; some jurisdictions are geo-walled until 2026-08-25 SGT during a data-deletion / independence cutover.

Verified Aug 2026

Memory / rules: Stateful Ubuntu env; desktop syncs local workspace tasks.

Mobile: App Store · Google Play

Pros: Autonomous Droid agents across the SDLC; supports fully air-gapped deployments for enterprise security.

Cons: Designed strictly for enterprise environments; less suited to quick solo experiments.

Memory / rules: Repository context; skills portable across CLI, IDE, and desktop.

Pros: Model-agnostic BYOK — any API provider or an existing subscription; Free self-host up to 10 users — Fair-source deploy on your own infra; Isolated container sandboxes — code and tests in throwaway clouds; Multi-channel steering — Slack, Telegram, and similar without an IDE; Broad SCM — GitHub, GitLab, Gitea, Azure DevOps, and Bitbucket.

Cons: No IDE integration — it is a standalone cloud agent; VS Code extension discontinued — the old Roo Code plugin is gone; Slow for exploratory coding — clone, spin-up, and self-review add latency; Launched mid-2026 — thin production history.

Memory / rules: Slack threads, integrations (repos, tickets, logs), cloud/self-host task state.

Pros: Was a web-based AI agent with its own cloud computer — browser tasks, skills/integrations, and code generation (web, Telegram, iMessage).

Cons: Shut down July 18, 2026 — Bud team joined Figma; hosted projects and deploys are offline. Kept here for historical reference.

Memory / rules: Cloud computer, browser sessions, connected tool skills.

Pros: Hosted web platform for full-stack Python apps with MCP and Skill.md support for agent-driven building.

Cons: Python/Reflex stack only; distinct from self-hosted reflex.dev framework.

Memory / rules: Reflex project state; MCP context.

Pros: Baidu hosted no-code AI platform for full-stack apps from natural language prompts.

Cons: Runs in Baidu's cloud; limited English documentation; niche market footprint.

Memory / rules: Hosted project and app state.

Pros: Open-source, browser-based IDE with real-time collaboration; generates full-stack Next.js apps with instant deployment.

Cons: Browser editor can lag on larger files; sometimes struggles with complex architectural intent compared to local IDEs.

Memory / rules: GitHub repo sync; real-time browser session memory.

Pros: Enterprise platform for AI app building on live data — prompt full-stack internal tools, Retool Agents (tool-use + HITL), and multi-step Workflows with evals, versioning, and observability; inherits SSO/RBAC from your org.

Cons: Not a local coding IDE; vendor lock-in; pricing scales for enterprise; steeper learning curve than pure vibe builders.

Memory / rules: Org resources, queries, workflows, and agent tool configs; reusable components across apps and agents.

Pros: Powered by proprietary Base 1 model; scaffolds databases, auth, and serverless functions; `npx base44 create` CLI for Claude Code/Cursor.

Cons: Heavy vendor lock-in to Base44 hosting environment.

Memory / rules: Entity schemas and backend state in code.

Pros: Access to frontier models; massive context window.

Cons: Barebones playground; lacks deployment features.

Memory / rules: 2M+ token massive context window.

Pros: Multi-agent full-stack generation — specialized agents split frontend, backend, and deploy; Built-in Stripe and Supabase — payments and DB from the prompt; Managed cloud deploys with GitHub sync — SSL and continuous deploy included; Pro unlocks custom agents and 1M context — system prompts you can edit; No-card free tier — 10 monthly credits for a first app.

Cons: Debug loops burn credits — generated bugs cost extra runs; Deploy is 50 credits per app per month — half a Standard allotment; Upgrade prompts in the editor — banners and gated features; Free tier blocks production — no GitHub, custom domains, or paid-app extras.

Memory / rules: Swarm multi-agent sync.

Pros: Prompt-to-app builder with hosted backend and quick deploy loops.

Cons: Limited architectural control; limited public market footprint.

Memory / rules: Abstracted application context.

Pros: Mobile-first vibe coding; generates app experiences from prompts.

Cons: Mobile-centric; less flexibility for complex backends; no time-boxed trial — Free is a tiny forever plan (25 credits, 1 public project, no private repos or code export); store binaries start at Starter.

Verified Aug 2026

Memory / rules: App blueprint and build state.

Pros: FlutterFlow-team builder with tri-surface editing — agent, visual canvas, and code stay in sync; Firebase/Supabase backends; web plus App Store/Play deploy; full Flutter project export on paid tiers.

Cons: Control is real on Hobby+ (canvas + code + export) but still Flutter-only and credit-gated; Free is 10 one-time AI credits and web deploy only.

Verified Aug 2026

Memory / rules: Design, canvas, and Flutter project state.

Pros: One-prompt full-stack web apps with instant preview and deploy.

Cons: Similar trade-offs to other browser builders; vendor lock-in risk; niche market footprint.

Memory / rules: Ephemeral build environment.

Pros: AI product builder focused on polished UI and fast iteration.

Cons: Abstracted stack; limited low-level control; limited public market footprint.

Memory / rules: Product and component memory.

Pros: Spec-driven software studio (plan → code → deploy) that rejects pure vibe scaffolding; optional human CodeBuddy designers/engineers; free trial + pay-as-you-go.

Cons: Not for legacy modernization; not all languages; not a local coding agent like Cursor.

Memory / rules: Spec and delivery project state.

Pros: Mistral’s hosted long-horizon agent (ex–Le Chat branding) for mixed knowledge work and coding; Free/Pro/Team; enterprise data-residency options.

Cons: Broader than a coding IDE; Mistral account lock-in; coding depth vs Claude Code/Cursor unclear from marketing.

Memory / rules: Hosted agent session and workspace state.