Home → Compare
aico vs the alternatives
There are a lot of good AI coding agents, and a separate crowd of chat-to-app builders people compare against them anyway. This page covers both: where aico is genuinely different, and — because a comparison that only flatters itself is worthless — where the alternatives are ahead.
Start with the honest part. Claude Code, OpenCode, OpenHands, Cline and Aider have between tens of thousands and a hundred thousand-plus users each. aico does not. If what you want is the best-supported tool with the largest community, the most extensions and the most Stack Overflow answers, one of those is the better choice today and it is not close.
What follows is about design decisions, not popularity.
At a glance
| aico | Claude Code | OpenCode | Aider | Cline | Cursor | |
|---|---|---|---|---|---|---|
| Source available | Yes (FSL) | No | MIT | Apache | Apache | No |
| Bring your own key | Yes | Anthropic | Yes | Yes | Yes | Subscription |
| Runs local models | Yes | No | Yes | Yes | Yes | Limited |
| Terminal | Yes | Yes | Yes | Yes | No | No |
| Own web UI | Yes | No | Desktop app | No | In VS Code | Is an editor |
| Editor extension | VS Code | Yes | Yes | No | Yes | n/a |
| Inline completion | No | No | No | No | No | Yes |
| Community size | New | Very large | Very large | Large | Large | Very large |
OpenAI's Codex CLI belongs in this table too and is not shown for space — same shape as Claude Code: closed source, no BYOK for third-party models, its own editor extension. It sits where Claude Code does in every row above.
Compiled August 2026 from each project's own documentation. Fast-moving software — check the source before relying on a row.
What is actually different about aico
It opens what it builds
This exists because of a specific failure: three models were asked for a single-file 3D space planner, and a keyword check scored two of them twelve features out of twelve. Opened in a browser, one threw on load and rendered nothing; the other was a shell. Nothing in the loop had ever run the thing.
VerifyApp opens the page in a real browser and reports what a
person would hit — uncaught exceptions, console errors, failed requests,
whether a <canvas> was ever painted, and whether named
controls do anything when clicked. Most agents check that the code looks
right. This one checks that it works.
The session is a log, not a chat buffer
Every fact is an append-only event with a sequence number. That is not architecture for its own sake — it is what makes a session resumable after a crash with real tool results rather than a summary, forkable from any message, and compactable without deleting anything. It is also why prompt caching actually hits: the cacheable prefix only ever grows.
One ledger for everything running
Sub-agents, background jobs, dev servers, scheduled runs and watchers share one record and one id space, and it survives a restart. You can ask "what is running, and what failed while I was away?" and get an answer. Limits — spend, deadline, idle — are set once and enforced by the platform rather than checked by the model. How that works.
It waits without burning turns
Asking most agents to wait for a build means a command, a sleep, and another command — a full turn and a full prompt per check. aico registers a watcher and stops; the platform wakes it. One turn to set, one to be woken by.
It can be driven by another AI
aico mcp-serve speaks MCP on stdin and stdout, so Claude Code or
any MCP client can delegate a task to it and collect the result. Nothing
listens on a port. Several tools consume MCP servers; being one is
less common.
In VS Code, a panel of its own
aico gets its own tab in the Secondary Side Bar, beside Chat — the same mechanism Claude Code and Codex use. It is not the web portal in a frame: the panel is drawn for the editor and styled from your theme, so tool cards and diffs match the colours of the file next to them.
It is not a second implementation either, and that distinction is the
reason it was worth building. The state layer, the reducer and every
transcript component are the browser client's, imported unchanged; the
panel is a view over them. A fix to how a failed Edit is drawn
lands in both surfaces because there is only one place it is drawn.
-
Edits arrive through the front door — a write is applied
as a
WorkspaceEdit, so Ctrl+Z takes it back and it shows in Source Control. A file changed behind the editor's back can do neither. -
It knows what you are looking at — the active file, your
selection with its line range, and the Problems for that file, shown as
chips so it is never a guess what a message will carry. Type
#to point at another file or a symbol. - Approvals are real dialogs — Auto, ask but not for edits, or ask every time. A card in a panel can be scrolled past while a turn sits blocked on it; a modal cannot.
- Background work in the status bar — a run started an hour ago, or a scheduled job that failed overnight, without opening anything.
What it deliberately does not do is inline completion. That is a different product, and Cursor and Copilot do it well. The full workspace is still one click away for the things a 300px column is the wrong shape for — Mini Apps, the trajectory view, the whole settings surface.
Not on the Marketplace yet; the .vsix is attached to each
release.
Where the alternatives are ahead
| If you want… | Use |
|---|---|
| The largest community, most extensions, most answers when stuck | OpenCode or Claude Code |
| Disciplined, git-native editing where every change is a reviewable commit | Aider |
| To stay inside VS Code, with an extension marketplace | Cline |
| A polished editor with inline completion and a company behind it | Cursor |
| A managed cloud service, or Kubernetes deployment for a team | OpenHands |
aico has no hosted service and no plan for one. There is a VS Code extension, and it is a native panel rather than the web portal in a frame — but it is still one engine. The server owns the run and the panel is a view over the browser client's own state layer, so it is not a second implementation of the agent, and it is not an inline-completion tool.
aico vs the app builders — Devin, Replit Agent, Lovable, Bolt.new
A different shape of product from everything above. Lovable and Bolt.new are chat-to-app builders — prompt in, app out, one review cycle at a time. Replit Agent is a full hosted platform (editor, database, auth, deploy) with an agent built in. Devin is an autonomous agent for an existing repo, closer to what aico is, but cloud-hosted and subscription-only. Anyone deciding how an AI should build their project ends up weighing these against a terminal agent anyway, so here is the honest look.
The honest part, again. All four of these have been used by vastly more people, for vastly longer, than aico has. Lovable reported $17M in ARR within three months of an update; Replit and Bolt.new each have large, active user bases. Devin has independently-verified benchmark results (SWE-bench) and third-party trial reports — aico's own numbers, below, are self-run, not independently audited, and should be read with that difference in mind. If what you want is the tool with the most real-world hours logged against it, one of these four is that tool today, and saying otherwise would be the exact mistake this page already warns against.
| aico | Devin | Replit Agent | Lovable | Bolt.new | |
|---|---|---|---|---|---|
| Source available | Yes (FSL) | No | No | No | No |
| Self-hosted | Yes | No | No | No | No |
| Bring your own key | Yes, 7+ providers | No | Partial (paid plans) | No | Partial (Bedrock) |
| Stack | 18 templates (Node, Python, Java, .NET, Go, PHP), or custom | Your existing repo | Flexible, hosted-locked | Fixed: Vite + React + Supabase | Mostly fixed, Claude-generated |
| Pricing model | Pay your provider, no markup | $20/mo + ~$2.25 per unit of work | Per-checkpoint, effort-based | Monthly + credits | Free tier, then token packs |
| Real spend, publicly reported | Cents per app in this project's own tests | Usage-driven, well past the $20 door fee | Reports up to $1,900+ in weeks on a small app | $30–400+/mo once credits and Supabase are added | Usually within the token plan |
| Autonomy | Plans, builds, verifies; you approve | Most autonomous — own sandbox, PR + human merge | Agentic; frequent correction reported | Turn-by-turn, not autonomous | Turn-by-turn, not autonomous |
| Independent benchmark | None yet | SWE-bench + third-party trials | None found | None found | None found |
| Self-run SWE-bench Lite result | 91% resolved (n=80, two independent random samples, no overlap) — evidence kept with the source | — | — | — | — |
| Git history | Every app, from the first commit | Yours already | Not the default flow | Exportable | One-click export |
Pricing and spend figures are publicly reported by each vendor or by users of theirs, compiled September 2026 — check the current plan pages before relying on a number here.
A real SWE-bench result, self-run. aico resolved
73 of 80 real SWE-bench Lite instances (91%) across two independent,
non-overlapping random samples — working blind, with no dependency
install and no local test execution, on the open-weight
deepseek-v4-flash model. Every failure in both runs was
individually checked against its actual test output, not just the
grading harness's aggregate score. This is not an
independently-audited or leaderboard-submitted number — it is
self-produced, using the standard swebench harness, and
SWE-bench's well-known contamination risk (these are years-old
public GitHub fixes) applies here as it does to any model's score.
Read that as "produced the correct patch reliably," not proof of
reasoning on genuinely unseen code. Full methodology, per-repo
breakdown, and every patch and test log are kept with the source
(benchmarks/swebench-lite).
Where aico is genuinely different
- No markup on the model. There is no credits system and no per-checkpoint billing — you pay whichever provider you chose, directly, at their price. A full-stack template build in this project's own live tests costs a few cents to about fifteen.
- Bring your own key, genuinely. Seven providers plus local Ollama, none of the four above offer that; the best any of them do is let a paid plan route through your own cloud account.
- The stack is a decision, not a default. Eighteen templates across six ecosystems for the well-trodden shapes, or hand the brief to the agent and get a stack it chose and justified in the PRD — never one framework you are stuck with.
- Ownership from the first commit, not an export button. Every app gets its own git history the moment it exists.
Where they are ahead
| If you want… | Use |
|---|---|
| The most autonomous agent, with independently-verified benchmark results | Devin |
| One hosted platform — editor, database, auth and deploy — with nothing to install | Replit |
| The fastest path from a sentence to a working visual prototype, no code read required | Lovable or Bolt.new |
| The largest real-world track record of any tool on this page | Any of the four above — all have far more hours logged than aico does |
Who it is actually for
- You want to keep your keys and pay providers directly, or run a local model.
- You want the agent to prove web work runs, not assert that it does.
- You run long or background work and want to see and bound it.
- You want to read the code that is running as you — its full source is public and heavily commented about why.
If none of those is a live problem for you, one of the tools above is probably the better pick, and saying so is more useful than pretending otherwise.