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; 500+ models; Kilo Desktop (beta) — native macOS/Windows/Linux app for code and data with multi-folder workspaces, Plan/Code/Ask/Debug modes, agent-edited notebooks, in-app conda, and built-in local 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/Desktop sessions and worktrees.

Cons: Kilo Desktop is still in beta (macOS, Windows, Linux); 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 or Go Plus $40/mo (higher limits) bundles curated open coding models — 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 Oct 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 is legacy but still selectable (disabled by default on Enterprise); Devin Local is the primary agent but lacks Cascade Memories and Workflows (migrate to skills); June 2026 rebrand from Windsurf.

Verified Oct 2026

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: Native Desktop app (no editor required) plus first-party CLI (`npm i -g cline`) for interactive terminal sessions or headless CI/automation — same agent core across all surfaces; Cline Cloud agents run tasks from the browser (mobile-friendly) in isolated cloud sandboxes — connect GitHub, pick a repo/branch, get a `cline/` branch or PR back; up to 10 parallel sessions, repo-scoped GitHub token, switch models mid-session, same Plan/Act and approvals; highly autonomous in VS Code/JetBrains with terminal and browser research; Connectors (beta) in Desktop and CLI (Gmail, Slack, Calendar, Linear, Sentry, Notion; `cline connect`); ClinePass (~$10/mo) is strong open-weight subscription value — curated models with 2–5× usage vs API rate across Desktop/CLI/IDE and via Cline API/SDK.

Cons: High token burn on BYOK or Cline usage-billing without ClinePass; managing keys if you skip the subscription; Desktop app still early (0.0.x pre-1.0); Cline Cloud is GitHub-only; connectors inside cloud sessions and Desktop `/cloud` hand-off still 'coming soon'.

Verified Oct 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; Apache 2.0 source on GitHub (zai-org/ZCode) — desktop, web/TUI, and Agent CLI.

Cons: 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 Sep 2026

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

Pros: Cosmos — the platform for building an always-on software delivery system, triggered from GitHub, GitLab, Slack, Linear, Jira, and webhooks; Context Engine maps the repo semantically; Prism router assigns work to frontier or open models per task; BYOK for LLM providers; native VS Code and JetBrains extensions.

Cons: Credit pools since Oct 2025 — non-rolling monthly credits replace unlimited-feeling usage; Persistent HTTP gateway timeouts — connection errors are a recurring complaint; CMEK remains Enterprise-only.

Verified Oct 2026

Memory / rules: Enterprise-grade context engine; Cosmos delivery triggers and webhook state.

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.7; 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 $49/user/mo (free for open-hardware repos; 200 managed credits/seat); Team adds platform fee on top of per-seat Cloud.

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 Oct 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: Reproduces bugs at runtime, parallel diagnosis agents, validated fixes, and local PR pre-review for vibe-coded apps.

Cons: CLI macOS-only (desktop app lists Windows/Linux).

Verified Oct 2026

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; AWS Console and Slack/Teams Q Developer continue beyond the IDE plugin wind-down.

Cons: IDE plugins lose support April 30, 2027; new IDE Free Tier signups and subscriptions blocked since May 15, 2026; best value inside AWS ecosystem; weaker outside it — not a whole-product shutdown.

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: Was ultra-fast tab completion with a 1M+ token context window; team joined Cursor (Nov 2024).

Cons: Sunset announced Nov 21, 2025 — no new product development; agent chat discontinued; VS Code users should migrate to Cursor Tab; Neovim/JetBrains plugins keep free autocomplete for existing customers only.

Memory / rules: Inline completion context only.

Pros: Qodo 3.0 (Oct 2026) adds PR Triage (research preview) work packages, review analytics dashboard (beta), Software Map blast radius, and Gerrit support; 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 and OpenAI 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; Cross-repo Context Engine is Enterprise-only.

Verified Oct 2026

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.

Verified Oct 2026

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 against Jira via Teamwork Graph; VS Code + CLI with parallel background tasks — capabilities moving into eligible Jira subscriptions as standalone Rovo Dev ends.

Cons: Ending as a standalone product (no separate long-term SKU); strong Atlassian lock-in; 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-first defaults; other OpenAI-compatible providers via BYOK; young brand.

Verified Oct 2026

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; BYOK (beta per docs/changelog); shareable sessions.

Cons: Early startup; marketing-heavy ($5M seed is fundraising, not a price tier); BYOK still beta; verify long-term pricing after promo credits.

Verified Oct 2026

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 OSS 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; vendor site now sells a demo-led hosted software factory — the OSS CLI (github.com/tailcallhq/forgecode, v2.14.0 Oct 1) lives on GitHub.

Verified Oct 2026

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 Qoder CN suite (formerly Tongyi Lingma) — IDE coding assistant with Individual Edition quick start and enterprise dedicated edition; Qoder CN CLI is a command-line agent alongside IDE plugins.

Cons: Alibaba Cloud coupling / China residency; large fast-moving Alibaba product surface.

Memory / rules: IDE, CLI, 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; built-in MCP (since v0.99.0) with Codemode — models compose MCP tool calls in a JavaScript sandbox, with tools loaded on demand via search; BYOK across many providers.

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

Verified Oct 2026

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; macOS (Apple Silicon) and Windows Desktop app (bundles the `dsh` command and plugin manager; tasks keep running with the window closed) plus local Web UI (`npx @deepseek-ai/dsh web`) and 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; releases are still rc/alpha (0.2.x), Desktop included; no Intel Mac Desktop build; 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 Oct 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: Browser extension for Chrome, Edge, Firefox, Brave, and Dia — in-page chat with ChatGPT, Claude, and OpenRouter; AI sidebar for page context; optional Desktop Bridge paid companion for deeper desktop integration.

Cons: Young browser-extension category; Desktop Bridge is paid, not the main interface; chat routing, not a Claude Code/Codex parallel harness; not a unified browser+IDE workspace.

Memory / rules: Extension session and page context; optional Desktop Bridge state.

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; optional OpenAI/Anthropic BYOK (vendor claim on kimchi.dev).

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

Verified Sep 2026

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; default auth and model catalog path is hosted Vercel AI Gateway (login or gateway key), with docs also citing Codex/Grok and a custom-connections preview — not OpenCode-class paste-a-key-for-every-lab on day one; native install is macOS/Linux only; WASM embed drops native MCP, skills, subagents, and OS sandbox vs the local CLI.

Verified Sep 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: Autonomous GitHub engineer: assign an issue and cloud agents open PRs with screen recordings, logs and review-ready diffs; built on the Pi harness with a codemode tool that runs tools in parallel in one call and a cache-friendly prompt; runs on many models; `reason` CLI runs locally, in the cloud (--cloud) or on your own server (--on); macOS app can use your local checkout and ports; iOS and Slack; HTTP API.

Cons: Benchmark lead is self-reported (Coding Agent Index 65.1 vs Codex 62.5 on GPT-6 Astra, their own preliminary harness runs, no independent verification yet); the agent always runs in Reason's cloud, even from the CLI; closed source product; no public price list; young company (Ara Software, Inc.).

Verified Oct 2026

Memory / rules: Cloud sessions keep their messages and results across web, iOS and macOS.

Pros: LangChain's open-source software factory on Deep Agents + LangGraph: investigates a repo, implements in an isolated per-thread sandbox, validates and opens a PR; reviews PRs and learns repo review preferences; watches CI on opted-in PRs (/baby-sit), scheduled tasks, read-only PR chat, subagents; start work from the web dashboard, GitHub issues/PR comments, Slack or Linear; `oswe` CLI and experimental desktop app can use your local checkout; pick models, sandbox provider (LangSmith default; Daytona, Runloop, E2B, Modal), skills and MCP per workspace.

Cons: Since Oct 16, 2026 every thread runs on LangChain Managed Deep Agents (private beta), so deploying it as-is needs beta access; otherwise you fork and adapt it; no hosted public app; LangChain says breaking changes are expected and it does not accept issues or contributions; sandboxes get installation-wide GitHub App access, so it is meant for one trusted team per deployment; you run the LangSmith, GitHub App and Slack setup yourself.

Verified Oct 2026

Memory / rules: Repo-root AGENTS.md appended to the system prompt; admin repo instructions; bundled, organization and per-user SKILL.md skills; per-thread persistent sandbox and LangGraph thread state.

Pros: Agent made for open models — coding (code projects with inline diffs, agentic code search) and documents/slides/sheets; runs local models (llama.cpp + MLX on the LM Studio runtime), models on your other devices via LM Link, or US-hosted open models in LM Studio Secure Cloud with Zero Data Retention; checkpoints/rollback, Auto Review for shell commands, Skills, Canvas (shared Excalidraw board), Introspection across past sessions; MCP including organization-managed MCPs; offline voice transcription (Voxtral); pairs with the LM Studio app (`lms` CLI, `llmster` headless daemon, OpenAI- and Anthropic-compatible APIs) and can use its loaded models (Bionic 1.1.8+, LM Studio 0.4.26+).

Cons: Separate closed-source app from LM Studio; cloud models need an account plus paid plan or credits; team subscriptions still coming soon; Splash engine speed figures are vendor claims.

Verified Oct 2026

Memory / rules: Checkpoints/rollback; Skills; Canvas (shared Excalidraw); Introspection across past sessions; MCP tool config.

Pros: Kimi Code runs on your machine — desktop app, CLI, and IDE plugins (VS Code/ACP); agent harness with shell mode; open-source MoonshotAI/kimi-code on GitHub.

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

Verified Sep 2026

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

Pros: Local OSS Rust coding agent with terminal TUI and local browser client (`codewhale web`) — BYOK via OpenAI-compatible endpoints and local models; VS Code extension path; optional Fleet orchestration.

Cons: Young OSS footprint vs Aider/OpenCode; desktop/hosted web still preview; catalog has not hands-on verified.

Verified Sep 2026

Memory / rules: Local TUI/web 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 free first-party MiMo out of the box; multi-provider TUI and desktop paths on the MiMo stack; BYOK across other 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: Installable desktop — brew install humanlayer/humanlayer/humanlayer, no waitlist; BYOK — plug in existing Claude Code, Codex, Copilot, Fireworks, and other subs without HumanLayer token markup; Opinionated QRSPI — Questions, Research, Design, Structure, Plan, Implement; Parallel sessions — run multiple agent instances at once; Free Starter for teams of three or less on the full IDE; Keyboard-first context engineering — session forking and QRSPI artifacts.

Cons: 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: MIT open-source, local-first agentic IDE/orchestrator that extends itself — ask once and it builds a plugin (sidebar panel + `bb <cmd>` CLI + a skill every agent can use); GitHub integration, agent memory, scheduled jobs, and remote access ship as plugins on the same system, plus a community plugin marketplace; Claude Code, Codex, and Pi built in, Cursor, OpenCode, Grok Build, Hermes Agent, omp, and other ACP agents once installed — each on your own subscription or API keys, billed by the provider, not bb; agents spawn and manage cross-provider child threads with parent notifications; per-thread worktrees, in-app browser, terminal, and file editor; `bb` CLI + HTTP API so scripts, cron, or your own bots can spawn threads; free bb connect for multi-machine remote access with iOS (TestFlight) / Android companion; roughly weekly releases (0.46.1, Oct 15 2026).

Cons: Orchestration only — install and log in to at least one agent CLI first; desktop app is stable only on Apple Silicon Mac (Windows/Linux builds are Alpha, Intel Mac via `npx`); README says workflows and surfaces are still evolving, with ~600 open GitHub issues; MCP server is Experimental and off by default; anonymous usage telemetry on by default (opt out with BB_TELEMETRY=false); mobile app is TestFlight/APK, not in the app stores; bb connect needs a bb account; catalog has not hands-on verified.

Verified Oct 2026

Memory / rules: Local server DB of threads/history across machines; parent/child thread trees; plugin-provided agent memory and scheduled jobs; skills library; wraps underlying harness AGENTS.md/CLAUDE.md.

Pros: Free MIT desktop app where an orchestrator chat turns your ideas into queued tasks that saved worker agents pick up in the background — on Claude Code, Codex, Cursor, Grok Build, OpenCode, Pi, or any ACP Registry agent, each on your own subscription with no resale or markup; per-thread git worktrees, diff review, and commit/push/PR from the app; tasks by status/tag plus scheduled tasks; cross-agent review hand-offs; managed browser and desktop computer use for every agent; built-in MCP server so outside agents (terminal Claude Code/Codex, ChatGPT) can start and steer threads; all chats in one local database; signed macOS (Apple Silicon + Intel), Windows, and Linux builds that self-update.

Cons: Fork of T3 Code (pingdotgg/t3code) — same runtime with a task/orchestrator layer on top, internals still say T3; very early (v0.0.x, mostly a single maintainer, ~90 stars); orchestration only — install and log in to at least one agent CLI first; new threads default to Full access permissions; product usage data goes to PostHog by default (opt out via T3CODE_TELEMETRY_ENABLED=false); unsigned Windows installer; mobile app not published yet; catalog has not hands-on verified.

Verified Oct 2026

Memory / rules: Local database of every thread across agents; task queue and status/tag routing; per-thread worktree/branch state; wraps underlying agent harness memory and skills.

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; mux command, protocol, and local data dir remain aliases after the Xum rename.

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: Tiered plans; routes to optimized open-weight models based on monthly evaluations.

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

Verified Oct 2026

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; desktop app macOS only (Apple silicon + Intel); MCP is a local session endpoint for launched panes, not a public Toolkit MCP.

Verified Oct 2026

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: Source-available 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 Sync.

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 Oct 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: Orchestration only (you still bring agent harnesses/models); factory usage billed separately from plan seats; vendor SDLC-automation stats; easy to confuse with Factory.ai Droid agents and with Warp Terminal/Agent CLI; early-access sign-up still shown.

Verified Oct 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 on the primary self-host path — no first-party hosted ADE (README notes an optional third-party hosted try at agent37.com/qm); orchestration only (bring harness subscriptions); Slack Code is the no-ops alternative if you only want partner agents inside Slack.

Verified Sep 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; iOS companion (TestFlight beta) to attach to Mac terminals; 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 Oct 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 ADE — free to try on Windows/Mac/Linux; agent-agnostic (Claude Code, Codex, Copilot, Cursor, Open Code, Auggie); Git-native parallel worktrees with Agent Graph orchestration.

Cons: GitKraken ecosystem coupling; closed-source; “self-hosted” means Git hosts (GHE/GitLab self-managed), not model BYOK; free-to-try does not mean forever free — pricing may evolve; catalog has not hands-on verified.

Verified Sep 2026

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

Pros: Gas City SDK for composable multi-agent orchestration — software-factory primitives (agent, bead, formula, rig, pack, event); local-first control plane; successor to Gas Town with migration docs.

Cons: Still young vs Conductor/Claude Squad; Gas Town still maintained separately (Yegge) — migration choice, not a hard cutover; orchestration only — BYO agent CLI costs; catalog has not hands-on verified; legacy Gas Town docs domain may 404/redirect.

Verified Sep 2026

Memory / rules: SDK 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: Hosted WebContainer vibe builder with Standard/Max routing; Bolt Forge (Sep 2026 research preview) = third agent picker mode on individual Pro — open models only (GLM 5.3 Flash, GLM 5.3; experimental Kimi K3, DeepSeek v4 Pro); vendor Bolt Build Index ~92.2 vs ~101 top paid (Sep 2026, their benchmark).

Cons: Forge open models are experimental — duplicate before a serious switch; keep complex production on Standard/Max; no PDF uploads on Forge yet; opt-in Forge shares de-identified sessions into licensed training datasets (EEA/UK/CH excluded); browser execution still throttles on large monorepos.

Verified Oct 2026

Memory / rules: Ephemeral browser dev environment; Forge vs Standard/Max agent picker.

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 preview test recording and Auto Sidekick (Dyad-routed two-model loop); 1.16 (stable) ChatGPT Plus/Pro subscription connect for building with your OpenAI plan; 1.17 beta experimental Claude Code subscription connect in Agent mode and experimental Cloudflare Workers deploy from the Publish panel; real exportable code; GitHub/Vercel or bring-your-own cloud; MCP client; Supabase; Apache 2.0 core.

Cons: Auto Sidekick and ChatGPT- or Claude Code-sub Agent modes use Dyad-routed models (not a reason to skip BYOK, but not always your own API keys); ChatGPT- and Claude Code-sub Agent modes add a small orchestration fee; Pro features under FSL in src/pro (not fully Apache); not a Cursor-class coding agent for existing monorepos.

Verified Sep 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 remotely; automatic stacked PRs on GitHub for large tasks (reviewable layers + auto-rebase when lower PRs change or review comments land); can restack existing oversized PRs; Fusion preview (vendor claim): frontier planner delegates mechanical work to a cheaper sidekick — Sep 28, 2026 vendor blog claims Fusion/Normal ~30–40% cheaper via newer models + harness.

Cons: Usage beyond plan quota bills on-demand; separate SKU from Devin Desktop IDE; stack quality still depends on DeepWiki/architecture seams; Fusion is preview; Cognition's own hard-task example lost a lot of score when the sidekick took the judgment calls.

Memory / rules: Cloud session state; stack readiness across CI/reviews; 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 on desktop, CLI, SDK, IDE, web, and Slack — every plan includes all products; cloud and local background agents; Plus and up add Droid Computers (Factory-managed cloud machines for remote Droids); BYOK with a free usage allowance on individual plans, and a free switch to Droid Core (open-weight models) when you hit standard rate limits; enterprise airgap build runs Droid with no outbound internet, on your own model endpoints; OpenCompute (private preview, Oct 14 2026) is a self-hosted orchestrator that spins up Droid sandboxes on demand inside your own cloud accounts or data centers (Kubernetes, EC2, AWS Lambda MicroVMs, or an in-house platform via gRPC drivers) over an outbound-only TLS connection, so internal repos, registries, and services stay private.

Cons: No free plan or trial on the pricing page — paid from $20/mo; rolling rate limits (Plus ~5x and Max ~10x Pro usage), with Extra Usage purchases past them; SSO/SAML, ZDR, audit logs, on-prem, and data residency sit in sales-led Business/Enterprise tiers; airgap builds are enterprise-only and drop cloud features such as session sync, Slack, and built-in web search; OpenCompute is private preview only (request through your Factory account team), still needs a live connection to Factory's control plane (not offline), and leaves your team running the infrastructure, upgrades, and capacity; its open-source release is announced with no date or license yet.

Verified Oct 2026

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: Conversation-first no-code builder for web/mobile products from plain language — generates UI plus backend/API/auth/DB when needed, publishes to a live MeDo URL (`*.appmedo.com`), and stays editable via chat after create; V3.7 polish includes Asset Library (reuse generated/uploaded media across projects; 100 MB Free / 1 GB Pro+Max / 10 GB Enterprise), one-click Preview runtime-error fix attempt, 30-day Project Recycle Bin, mid-chat Skill setup without leaving the task, smoother cross-image editing plus image→video workflow, and Preview remembering last view mode; shared backend across Website/App/admin channels (one data model, multiple frontends); documented iOS TestFlight/App Store Connect and Android app-packaging paths; English docs at docs.medo.dev and canonical agent handoff at medo.dev/skill.md (`?query=` deep links through sign-in); docs describe a Claude Code/Cursor build-from-agent path.

Cons: Baidu-associated hosted cloud — residency and trust expectations differ from Western vibe builders; niche footprint vs Lovable/Bolt; credit-metered everything (Deep/Fast Build, publish, backend keep-alive at 15 credits/app/day — shared backends still bill per connected app, Skills per call, source export 300 credits, packaging 300–500 credits); Free-plan backends pause after 5 days project inactivity unless Pro+ keep-alive; AGENTS.md posture unknown — skill.md is the published agent contract; agent-build path is docs-guided, not an in-repo coding agent.

Verified Sep 2026

Memory / rules: Hosted project; Asset Library; Skills configured in chat; shared backend and channel state; 30-day recycle bin; preview view mode.

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 (15 credits, 1 public project, no private repos or code export); store binaries start at Starter.

Verified Oct 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: Invite-only messenger that gets things done — group trips, bills, school, and similar shared tasks; vendor/press (Sep 2026) says it still builds interfaces in chat, not a separate vibe-coding IDE.

Cons: Invite-only access; pivot away from AI product builder — less low-level stack control; young post-pivot footprint (vendor/press claim).

Memory / rules: Messenger threads and in-chat mini-app state.

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.