> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kanaeru.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Compared with other tools

> How Kanaeru relates to IDE assistants, CLI agents, cloud AI engineers, app builders, and spec frameworks: where it overlaps and where it fits alongside them.

AI coding tools fall into five broad groups. Kanaeru works alongside some of them and overlaps with others. This page is about where each one fits, not about which is best. Many of these tools change every month, so check their own documentation for current features.

## At a glance

| Group | Examples | How Kanaeru relates |
| - | - | - |
| IDE assistants | Cursor, VS Code with GitHub Copilot, JetBrains AI | Works alongside. Use your editor to read and adjust what Kanaeru opens |
| CLI coding agents | Claude Code, Codex CLI, Copilot CLI, opencode | Works alongside. These are the [runtimes](/machines/runtimes) Kanaeru runs on your agent machines |
| Cloud AI engineers | Devin, Factory, Codex cloud, Copilot cloud agent, Jules | Overlaps on asynchronous pull requests |
| App builders | Lovable, Bolt, Replit Agent, v0 | Mostly a different audience |
| Spec frameworks and orchestrators | Kiro, GitHub Spec Kit, BMAD Method, Conductor | Overlaps the most |

## IDE assistants

Editor-based assistants are best when you want to stay hands-on: completions, inline edits, and agent chats in the file you have open. Several now run background or cloud agents too.

Kanaeru doesn't replace your editor. Kana's work arrives as branches and pull requests, so you can open them in whichever editor you like, review them, and push your own changes to the branch.

## CLI coding agents

Terminal agents take one task in one repository and work through it with you. They are the strongest building block in this list, and Kanaeru is built on them rather than against them. The Agent Manager on each agent machine runs Claude Code, Codex, Copilot CLI, opencode, and the other [supported runtimes](/machines/runtimes) with the sign-ins you already have.

What Kanaeru adds on top of a single CLI session:

* The outcome around the task: a vision, a roadmap, approved blueprints, and a plan you sign off before anything is built.
* Up to three tasks of an outcome running at once, each on its own branch in its own worktree.
* A choice of runtime and machine for each message of a session, so you can move a session to another machine or runtime instead of starting over.
* Agents that stay with each pull request and handle review findings and CI failures.

## Cloud AI engineers

Cloud agents take a well-scoped issue and return a pull request from the vendor's sandbox. Many show a plan before they start, coordinate several sessions, and keep notes between runs. That overlaps with Kanaeru's execution phase.

The differences are in what comes before and where the work runs:

* **What gets approved up front.** Kanaeru plans with [blueprints](/concepts/blueprints) such as UX mockups, user journeys, API contracts, and data models. You approve them before execution, and the delivery is checked against them. A cloud agent's plan is usually a list of steps.
* **Where the code runs.** Kanaeru runs agents on the [agent machines](/machines/connect-a-machine) connected to your account: a cloud machine Kanaeru manages for you, or your own computer with the runtimes and accounts you already have. By default, agents run [sandboxed](/machines/sandboxing) there. On your own computer you can turn the sandbox off, and native Windows has no built-in sandbox.
* **Which agent does the work.** You choose the runtime for each session instead of a single vendor's agent.

## App builders

Prompt-to-app builders turn an idea into a hosted app with a backend, sign-in, and a database. They suit new products and people who don't write code.

Kanaeru is aimed at engineering teams working in existing repositories. It delivers pull requests to your repositories and integration branch rather than hosting the app for you.

## Spec frameworks and orchestrators

This is the group closest to Kanaeru. Spec-driven tools turn a feature idea into requirements, a design, and a task list before writing code. Some run tasks in parallel, open pull requests, or learn from review feedback. Orchestrators run several coding agents side by side in separate worktrees.

Frameworks that run inside your coding agent, such as Spec Kit or BMAD, can also run inside the runtimes Kanaeru uses. What Kanaeru brings that these tools usually don't combine in one place:

* Blueprints that cover the user experience as well as the code: clickable UX mockups and user journeys, next to API contracts, data models, and state machines.
* Gates you control between [phases](/concepts/outcomes), including an understanding check before execution.
* Pull request care through CI and review, then delivery pull requests checked against the evidence.
* A [retrospective](/concepts/learning-loop) whose learnings you approve before later sessions use them.
* Work that runs on your connected agent machines, managed in the cloud or your own, with your choice of runtime.

## Choosing

* Use an **IDE assistant** or a **CLI agent** on its own for a quick change you'll make yourself.
* Use a **cloud agent** to hand off a small, well-scoped issue.
* Use an **app builder** to try out a new product idea without a codebase.
* Use **Kanaeru** when the work spans several tasks or repositories and you want to approve what will be built before it's built, then follow it through review, CI, and delivery.


## Related topics

- [Blueprint editor and tools](/guides/blueprint-editor.md)
- [Session plugins](/machines/session-plugins.md)
- [Kanaeru app tools](/mcp/tools.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.