Aide

Aide is an open-source AI-native IDE built by the Codestory team as a fork of VS Code. Where Cursor adds AI to VS Code, Aide rebuilds the IDE from the ground up around agent-first workflows. The editor tracks your recent edits, maintains local memory of project context, and uses that to proactively suggest changes before you ask. The core is MIT-licensed and self-hostable. A paid tier adds hosted agent capabilities and cloud sync. For developers who want an open alternative to Cursor with a stronger orientation toward autonomous agent workflows, Aide is the most interesting option in the category.

Most AI coding tools fall into one of two categories. The extensions, like Cline or Continue, drop into your existing editor and add AI capabilities. The forks, like Cursor, replace your editor entirely with a version that has AI built in. Aide is in the fork category, but it's taking a different design position than Cursor. Where Cursor started as a great editor with AI added, Aide is designed as an agent environment that also happens to be a great editor.

That's not just marketing framing. The architecture reflects it. Local memory, proactive suggestions, agent-first workflows: these are core to what Aide is rather than features added on top of an existing editing model. The Codestory team launched in early 2024 and has been building toward this vision of an IDE that's designed for working with AI agents as a primary mode, not as an optional capability you turn on when you need it.

The other thing that sets it apart: it's genuinely open source, MIT-licensed, self-hostable. That's not a small thing in a category where most tools are proprietary SaaS products with no way to run them on your own infrastructure.

The local memory system

The feature Aide is built around that Cursor doesn't have is local memory. The IDE tracks your edits over time and builds a persistent, local knowledge layer about your project. It knows which files you've been working in, what patterns you follow, what problems you've been debugging, how your project is structured. This context carries across sessions.

When you open Aide the next morning on the same project, the agent doesn't start from zero. It has a working model of the project built from what you did yesterday. When it suggests a change, it's using that accumulated context rather than just the currently open files.

This matters more than it might sound. One of the friction points with AI coding tools is that each session starts cold. You either write a detailed project brief in a config file, or you spend the first part of each session re-establishing context. Local memory eliminates much of that. The tool gradually gets better at your codebase the more you use it, rather than being the same from session one to session one hundred.

The "local" part is deliberate. The memory is stored on your machine by default, not synced to a cloud service. For developers working on code that can't leave their network, this is significant. You get the benefits of persistent context without the tradeoff of sending your codebase history to an external service.

The paid tier adds cloud sync for teams who want the memory accessible across machines. But the open-source, locally-stored version is fully functional for individual use.

What "agent-first" actually means in the editor

Agent-first is a phrase that gets applied loosely to a lot of tools. In Aide's case, it has a specific meaning: the editor is designed for the agent to take multi-step actions, not just for you to ask questions and get answers.

In a completion-first editor like a standard VS Code with Copilot, you write code and the AI suggests what comes next. In a chat-augmented editor, you open a chat panel, describe what you want, and the AI produces a suggestion you accept or reject. In an agent-first editor, you describe a goal and the AI takes multiple actions to achieve it: reading files, editing code, running tests, checking output, iterating based on results.

Aide puts the agent workflow in the center of the design rather than the periphery. The inline agent can take actions across your project, not just in the current file. It has terminal access. It can run your test suite, see the output, and decide what to fix. It tracks the results of its own previous actions within a session.

The proactive suggestion system extends this to unprompted action. Aide watches what you're editing and, based on your recent changes, may surface suggestions about related code that probably needs to change too. If you rename a function in one file, Aide may proactively note that two other files call that function and suggest updating the call sites without you asking. That's the agent working in the background rather than waiting to be invoked.

The open-source architecture

Aide is built on the same Open VSX and VS Code base that Codium and other VS Code forks use. The full source is available on GitHub at codestoryai/aide. The license is MIT, which means you can fork it, modify it, and run it on your own infrastructure without restrictions.

Self-hosting Aide is a real option, not just a theoretical one. The build process is documented, and because it's built on VS Code's extension model, deploying a custom build doesn't require specialized infrastructure knowledge. You need a machine that can run an Electron app, which is essentially any developer machine.

For organizations with strict requirements about AI tools and data handling, this matters. You can audit the code, modify what it does with your data, and run it entirely on your own infrastructure. You're not taking Cursor's or Anthropic's word for what happens to your code. You can read the source.

The GitHub repository has been actively maintained since launch with regular releases. The contributor community is smaller than Cursor's or Cline's, which is expected given the age of the project and the scope of what they're building. But the release cadence is consistent, and the core functionality is stable.

Pricing and the free tier

The open-source core is free. You install it, you configure your own API keys (or use Aide's hosted models), and you're using a fully functional AI IDE at no cost beyond API usage.

The paid subscription, available through aide.dev, adds hosted agent capabilities and cloud sync. The specific pricing is visible on the website. It's aimed at developers who want the full managed experience rather than self-hosting and managing their own API keys.

The free, open-source tier is genuinely good. It's not a crippled free version that pushes you to upgrade. The limitations in the free tier are about managed infrastructure and cloud features, not about core functionality. If you're comfortable bringing your own API keys and running things locally, you don't need the paid tier.

This is the right approach for an open-source product in a market where many tools call themselves "open source" but gate the actually useful features behind a paywall.

Where Aide stands relative to alternatives

The comparison to Cursor is the obvious one. Cursor is the dominant AI IDE fork with a large team, polished UX, and a proven product. For most developers who want an AI-first editor today, Cursor is the default recommendation because it's the most complete product.

Aide's advantages over Cursor are open source (self-hostable, auditable), local memory as a first-class feature, and the agent-first design orientation. If those specific things matter to you, Aide is worth using. If you want the most polished daily editing experience with strong autocomplete and a large support community, Cursor is ahead.

The comparison to Zed is different. Zed is an open-source editor built in Rust for performance, with AI features being added as the product matures. Zed's orientation is toward speed and collaborative editing, with AI as a secondary focus. Aide's orientation is toward AI-first workflows, with the editing experience being solid because it's built on VS Code. Pick Zed if raw editor performance and open-source collaborative editing are the priority. Pick Aide if agent-first workflows are the priority.

Against Continue, which is an open-source extension for VS Code rather than a fork, the difference is depth of integration. Continue adds AI capabilities to your existing VS Code setup without replacing the editor. Aide rebuilds the editor around AI. Continue is the lower-commitment option. Aide is for developers who've decided they want the full AI-native IDE experience and want an open-source version of it.

Against Claude Code, the comparison is IDE versus CLI. Claude Code is a terminal agent that works outside any specific editor. Aide is an editor. They can coexist in a workflow: Claude Code for large cross-cutting tasks from the terminal, Aide for editor-integrated work. They're not directly competing for the same workflow.

Who should actually try Aide

If you're evaluating AI IDEs and you have any of the following requirements, Aide belongs in the evaluation:

You need to self-host. Cursor is not self-hostable. Aide is. If your organization has compliance requirements that rule out sending code to Cursor's cloud, Aide is one of the only real alternatives.

You want an open-source foundation you can extend. If you want to modify the AI behavior, add custom integrations, or audit what the editor does with your code, open source is the prerequisite and Aide has it.

You're interested in agent-first workflows as a primary mode rather than a secondary one. If the main thing you want from an AI IDE is the ability to describe goals and have the agent work toward them across your project, Aide's design fits that use case better than editors that started from a completion-first model.

You want local memory without cloud sync. The local memory feature is available in the free, open-source version and doesn't require syncing your project history to a cloud service.

If your main criterion is "best daily editing experience with the most polished AI integration," Cursor is still ahead. That gap will narrow as Aide's team and community grow, but it exists today.

Getting started

Download the Aide installer from aide.dev or build from source from the GitHub repository at codestoryai/aide. The installation is the same as any Electron app.

On first launch, you'll connect an AI provider. Aide supports the major API providers. Start with whatever model you use elsewhere so you have a baseline for comparison.

Give it a few sessions on a real project before evaluating it. The local memory system improves over time, and the proactive suggestion quality is better after the editor has seen a few editing sessions worth of context. A first-session evaluation misses the thing that makes Aide interesting.

For the agent workflows, start with a concrete, bounded task: "add input validation to this function and update the tests." See how the agent moves through reading the existing code, making the change, running the tests, and iterating. That pattern is the core of what Aide is designed for.

The bottom line

Aide is a genuine option in the AI IDE category, not a clone or a side project. The Codestory team is building something with a coherent design point of view: open source, agent-first, local memory. Those aren't random features, they're a coherent response to specific limitations of the dominant commercial tools.

It's not ahead of Cursor on polish or completeness right now. It doesn't need to be to be worth using if the open-source requirement or the agent-first design are important to you. For developers who need to self-host or who want to build on top of an open AI IDE codebase, Aide is the most interesting thing in the category.

Key features

• Full VS Code fork with AI agent capabilities built into the IDE layer
• Local memory that persists project context across sessions
• Agent-first workflows where AI can take multi-step actions within the editor
• Proactive code suggestions based on recent edits and open files
• Inline chat with deep editor context awareness
• Tool calls and terminal access for autonomous task execution
• Open source codebase you can self-host and modify

Pros and cons

Who is Aide for?

• Developers who want a Cursor-like AI IDE that they can self-host and modify
• Engineers building on sensitive codebases who can't use cloud-based AI services
• Developers who want agent-first workflows embedded in the editor rather than as an extension
• Teams evaluating open-source alternatives to commercial AI coding tools

Alternatives to Aide

If Aide isn't quite the right fit, the closest alternatives are cursor , zed , claude-code , and continue . See our full Aide alternatives page for side-by-side comparisons.