Aura IDE
A desktop AI coding workspace for repository-aware changes, validation, reusable agent teams, and controlled diff approval.
- Source repo
- CarpseDeam/Aura-IDE
- Stars
- ★ 56
- Last updated
- 12d ago
- License
- MIT
- Primary language
- Python
- FA score
- 77/100 · Good
At a glance
- Works with
- Universal · cross-platformOpenAI API · Claude API
- You'll need
- Typical use
- A developer making a focused change in an existing repository can ask Aura to identify an under-tested function, add a test, run it, and explain the outcome.
- Main limitation
- macOS and Linux require a source installation, but the supplied material does not include complete copyable installation or launch commands.
- Source review
- 77/100 · Good
What does this agent do, and when should you use it?
Aura IDE is an open-source desktop coding application that places conversation, project files, source code, and execution results in one workspace. It reads and searches repositories, follows references, and uses project tools and the terminal to make and validate changes. A task can run through Aura directly or be divided among Agents with their own instructions, model choices, and permissions. Agents can be connected into reusable Teams whose assignments and branches are visible in a graph editor. The application supports hosted DeepSeek, OpenAI, Anthropic, Gemini, and OpenRouter connections as well as Ollama, LM Studio, llama.cpp, and compatible OpenAI-style local servers. It is a practical fit for developers who want multi-model flexibility while retaining diff review, read-only or planning controls, and isolated worktrees for Agent changes.
The user opens a project folder and either adds a hosted provider key under Settings → API Keys or connects a running local server under Settings → Models. Aura reads and searches the repository, follows code references, and works through project tools, Git, and terminal tools; its workspace exposes tool activity, terminal output, checks, failures, and a final report. With Agents enabled, Aura can assemble a team or invoke a saved Team, while each Agent can inherit Aura's current model or use another configured model and thinking level. A Team connects Agent assignments into a graph that can be arranged, edited, extended with branches or helpers, and run again for a new task. Writable Agent work takes place in isolated worktrees, after which retained changes are reviewed and applied through Aura; manual approval can also require inspection of proposed diffs before writes. Aura can connect to MCP servers, while Aura Companion lets a phone browse projects, send messages, and follow work through a local or hosted relay as long as the paired desktop remains running.
- A developer making a focused change in an existing repository can ask Aura to identify an under-tested function, add a test, run it, and explain the outcome.
- A team that repeatedly follows an implementation-test-review sequence can save those responsibilities as a Team and rerun the workflow with new tasks.
- A maintainer working in a sensitive repository can use Read Only, Plan review, or manual pre-write diff approval to restrict how changes are made.
- A developer evaluating model options can mix hosted and local models in one Team and select a separate configured model for each Agent.
- A user supervising a long-running desktop task can pair Aura Companion, browse the project from a phone, and monitor progress while the desktop stays online.
How do you install or deploy this agent?
On Windows, download and run the latest .exe from GitHub Releases. Python is bundled, installation is per user, and subsequent updates are available inside Aura.
On macOS and Linux, Aura must be run from source with Python 3.10 or newer. The supplied material does not provide the exact repository-cloning, dependency-installation, or launch commands, so a verified command-line installation sequence cannot be reproduced here.
For first use, also provide either an API key for a supported hosted provider or a running local server such as Ollama, LM Studio, or llama.cpp. Local coding requires a model or server with tool-calling support and enough context for the task.
How do you use this agent?
- Open a project folder.
- For a hosted model, add its key in Settings → API Keys. For a local model, connect its running server in Settings → Models.
- Submit a small first task such as: Find a function that needs a test, add one, run it, and explain the result.
- Inspect the changed files, proposed or retained diffs, and reported validation results.
- For multi-Agent work, enable Agents and let Aura assemble a team or select a saved Team.
- To define a reusable process, ask Aura to create a workflow that implements a requested change, tests it, and reviews it. Creation saves the workflow without executing it; inspect or revise its graph, then select Run and provide a task.
- Review writable Agent changes from their isolated worktree and apply the changes you want to retain through Aura.
What are this agent's strengths and limitations?
- Supports five named hosted options and several local-server paths, with hosted and local models usable together in one Team.
- Agents and Teams can be saved, refined through conversation, and inspected in a graph editor with explicit assignments and branches.
- Manual pre-write diff approval, Read Only, Plan review, and isolated Agent worktrees provide several concrete layers of change control.
- Project files, chat, tool activity, terminal output, validation results, failures, and the final report are presented in one desktop workspace.
- The Windows installer bundles Python and supports in-app updates, reducing runtime setup for Windows users.
- macOS and Linux require a source installation, but the supplied material does not include complete copyable installation or launch commands.
- Hosted providers charge separately for API use and require the relevant credentials.
- Local operation depends on a separately running Ollama, LM Studio, llama.cpp, or compatible server, plus a model capable of tool calling and adequate context.
- Aura Companion is not an independent execution host; the paired desktop must remain running.
- The documented completed example is a small Python project, leaving performance and reliability on large repositories, other languages, or complex Agent graphs unproven.
How does this agent compare with similar options?
Unlike a hosted-API-only setup, Aura can connect to Ollama, LM Studio, llama.cpp, and compatible OpenAI-style servers, allowing model execution to remain local; the tradeoff is that the user must operate the server and choose a model with tool calling and sufficient context. Its hosted choices—DeepSeek, OpenAI, Anthropic, Gemini, and OpenRouter—offer a more direct connection path but incur provider API charges. An individual Agent suits a reusable standalone role, while a Team is intended for saved, visual workflows that connect responsibilities such as implementation, testing, and review.
Key facts side by side with the most closely related agents.
| Agent | Source review | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|
| Aura IDE This agent | 77 · Good | ★ 56 | 12d ago | Python | OpenAI API · Claude API |
| Pi Dynamic Workflows | 88 · Good | ★ 531 | 10d ago | TypeScript | — |
| Fusion Software Factory | 71 · Some gaps | ★ 1.2k | today | TypeScript | Codex · OpenAI API · Claude API |
| Mysti AI Coding Team | 58 · Major gaps | ★ 1.1k | 3mo ago | TypeScript | Codex · Claude Code · OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The tests show strong least-privilege and authority boundaries: restricted root turns refuse writable delegation instead of silently downgrading it, Agent permissions are frozen at submission, delegation tools disappear when unavailable, and traversal or link-like definition paths are rejected. Applying or discarding retained work requires approval and the primary workspace is revalidated afterward; isolated worktrees, checkpoints, journaled states, and cleanup-pending recovery provide thorough rollback evidence. The README identifies major external channels—hosted models, local servers, MCP, terminal, Git, and the mobile relay—but does not fully state what each receives, retention behavior, or processing responsibility, so data-flow transparency and external-effects handling are not complete. API keys are only described as settings entries, with no supplied evidence about encryption, storage, log redaction, or rotation, limiting sensitive-data handling to a thin score. Dependencies use broad minimum versions without a lockfile, supply-chain scanning, or vulnerability-response evidence, so dependency security is weak. The MIT notice and project naming provide attribution, but the copyright holder is only “Aura” and publisher identity remains unknown, preventing full source-attribution credit; unknown identity is not treated as suspicious.
README claims about approvals, isolated Agent work, visible failures, and retained changes align with the authority, boundary-hardening, and transaction tests. Tests cover persistence errors, locking, dirty worktrees, missing refs, Git failures, approval races, and cleanup failures while asserting structured failure classes and truthful state, supporting full self-consistency and failure-message scores. Python requirements, the executable entry point, and dependencies are declared, and Windows and source-install paths are described. Dependency availability is not full because versions are not locked or upper-bounded, some tests can skip when PySide6 is absent, and model services, Git, and local servers remain external availability requirements.
The material addresses Windows desktop users, macOS/Linux source users, hosted and local models, individual Agents and reusable Teams, and read-only, plan-review, and writable workflows, giving strong audience and scenario coverage. Permission enums, root-turn mutation restrictions, context-sensitive tool exposure, exclusion of private child instructions from the model-visible roster, and bounded diff inspection establish clear capability boundaries. Trigger behavior has implementation-level tests, but the supplied evidence does not include the complete system prompt, every tool-routing path, or false-trigger evaluations, so trigger precision is not full. Environment support spans Python 3.10+, multiple providers, and OpenAI-style local servers, but only Windows has the described packaged install; macOS/Linux require source execution, and local coding depends on tool-calling support and adequate context.
The README has clear sections for onboarding, Agents and Teams, models, safety controls, mobile access, and support, earning strong information-architecture credit. Windows setup is concrete and other systems are directed to an installation guide, but that guide's commands and troubleshooting content are not supplied. Aura, Agent, Team, and change-set terminology is generally consistent, although the generic package name “aura” and unusual “2.3.04” version format leave limited evidence of long-term naming stability. Practical prompts and a workflow example are present, but no actual FAQ is included. Hosted-provider costs, local-server requirements, and the desktop-uptime requirement are disclosed, though there is no comprehensive known-issues section. The complete MIT text justifies full license credit. A version and Releases path exist, but no changelog or compatibility policy is included. Issues, Discord, and sponsorship routes are named, yet no maintainer identity, support commitment, or security contact is established; with publisher identity unverified, maintenance responsibility remains thin.
The output is designed for practical review: users can inspect proposed diffs, tool activity, terminal output, checks, and failures. Agent changes remain as inspectable change sets, while binary and oversized content is explicitly represented with omission notices, size, hashes, and truncation state, giving strong output-usability evidence. Reusable Teams, graph-based workflows, model mixing, and isolated retained changes plausibly add value over a basic coding chat, but no comparative study or user outcome data is supplied, so marginal value is not full. The product is MIT-licensed and supports local models while clearly warning that hosted APIs cost extra; however, token usage, latency, resource consumption, and orchestration overhead are not quantified, limiting the cost-benefit score.
Important safety and recovery claims trace to focused assertions covering frozen authority, path boundaries, approval, transaction states, post-approval revalidation, and failure classification. Metadata independently exposes version, dependencies, entry point, and licensing, supporting strong claim traceability. Multiple test files corroborate the README's central control claims, while the license and project metadata add different source types. The deduction concerns promotional statements such as Aura being developed with Aura and the cited example-run outcome, which are supported only by the project's own narrative or referenced screenshots; the material also does not consistently label demonstrations, design goals, and verified behavior as separate categories.
- Before submitting private code or credentials, verify exactly what each hosted model, MCP service, and mobile relay receives, retains, and logs.
- The supplied static material does not document encrypted API-key storage, redaction, rotation, or deletion; review these controls separately before production use.
- Dependencies use broad minimum versions, with no supplied lockfile, SBOM, vulnerability scan, or security-update policy, so builds and supply-chain exposure may change over time.
- Worktree isolation and approval flows have strong test evidence, but this assessment did not execute the application; validate approval defaults, recovery behavior, and failure presentation on the target platform.
- macOS/Linux require source installation, and local models must support tool calling with adequate context; perform a limited compatibility trial first.