Aura

Aura v1.8.0 is a milestone release.

This release moves Aura forward on three fronts at once: it becomes easier for new users to try, safer and smarter during real code work, and much more capable as a reusable workflow system.

Aura now has a clearer product path with Aura Credits, a rewritten README, a simpler Drone workflow, deeper repo context through dependency mapping, and a harder to break Worker execution loop.

Aura is still open source. Bring your own key still works. But v1.8.0 adds the path for someone to install Aura, buy credits, select Aura as a provider, and start working without managing model API keys.

Highlights

Aura Credits

Aura now has a dedicated Settings → Aura tab for hosted credits.

You can:

• Buy Aura Credits from the desktop app
• Claim a completed checkout on the same device
• Save an Aura key locally
• Refresh and view your credit balance
• Use Aura as Planner, Worker, or both

This gives Aura two model access paths:

• Bring your own provider keys
• Use Aura Credits for hosted Aura models

The Aura Credits page now acts like a small account dashboard: balance, purchase flow, claim flow, and key management all live in one place.

Rebuilt README

The GitHub README has been rewritten around what Aura actually is now:

An open-source AI workflow IDE / coding harness where the model is the fuel and the harness is the engine.

The README now explains the Planner → Worker loop, Aura Credits, Drones, Workbay, safety controls, quick start, and the “built with Aura” story in a cleaner order for new users.

Simpler, more useful Drones

The Drone workflow has been retooled around a simpler UX and actual useful reusable workers.

Drones are no longer treated like a side experiment. They are becoming first-class project machinery: build them, keep them, run them, loop them, and use them as repeatable tools inside a workspace.

This release improves:

• The Drone creation and usage flow
• Project-local Drone behavior
• Workbay usability
• One-click Drone runs
• Loopable Drone runs
• Receipts and run output
• Read-only Drone investigation
• Write-capable Drone execution through Aura’s approval path

The goal is simple: useful AI work should become reusable machinery instead of disposable chat.

Dependency graph and better repo intelligence

Aura’s repo context now includes dependency graph awareness.

That means the Planner and Worker can reason with more than a flat repo map. They can see more of the connective tissue: imports, dependents, and the blast radius around a change.

This matters most during refactors. The dangerous part is rarely the file being edited. It is the quiet little files depending on it from across the project.

v1.8.0 adds dependency graph context for structural planner prompt injection and Worker awareness, making Aura better at understanding what a change might affect before touching code.

Dependent-import verification

Verification is now smarter around dependency impact.

When a changed file has dependents, Aura can gate on the changed file itself and inform on dependent imports. That keeps the verification loop focused without pretending nearby dependent files do not exist.

This release also fixes a classification-order regression in verification, making failure classification more reliable when multiple signals are present.

Stale Planner context fix

A stale Planner context bug has been fixed.

After returning from Worker execution, the Planner now gets fresher structural context instead of reasoning from an outdated repo view. This matters after edits, refactors, and file movement, where stale context can quietly poison the next plan.

ConversationManager refactor

ConversationManager has been split into smaller submodules.

This is internal cleanup, but important cleanup. It reduces god-file pressure, makes the conversation system easier to reason about, and creates cleaner ownership boundaries for future work.

Aura has grown fast. v1.8.0 starts paying down the structural debt in the parts of the app that carry the most weight.

Worker reliability and command verification

The Worker execution loop is tougher now.

This release adds a new run_and_watch verification rung that classifies command results more carefully:

• Tracebacks are treated as failures even when a command exits cleanly or exits early
• Terminating-command behavior is preserved byte-for-byte
• Clean exits and real failures are separated more reliably

This matters because command output is not just text. It is evidence. Aura now reads that evidence more carefully.

Contract-supplied command execution

run_command ignition has been tightened.

run_and_watch is now wired as the Worker tool through a contract-supplied path. The Planner declares it through dispatch_to_worker, and the Worker cannot choose or override the execution mechanism.

That closes an anti-mirror hole: the model does not get to reinvent how command execution works. Aura supplies the contract. The Worker uses it.

This was verified end-to-end.

Safety and control

Aura’s core safety model remains the same:

• Planner writes the spec
• Worker executes through controlled tools
• User reviews diffs before writes
• Existing files are backed up
• Validation runs after changes
• Git integration keeps work recoverable
• Worker receipts explain what happened

v1.8.0 strengthens that loop without removing the control that makes Aura safe to use near a real codebase.

Why this release matters

Aura has always been about the harness, not the model.

The model supplies intelligence. Aura supplies the engineering loop: repo context, planning, tool use, diff approval, validation, recovery, receipts, Drones, and reusable workflows.

v1.8.0 is the release where those pieces start locking together:

• New users get a clearer path in
• Aura Credits make hosted use possible
• Drones become useful project-local machinery
• Dependency graph context makes planning smarter
• Verification catches more real failures
• Command execution is more controlled
• The codebase itself gets cleaner

This is a product release, a reliability release, and an architecture release at the same time.

Upgrade notes

• Existing provider API key workflows still work.
• Aura Credits are optional.
• Existing local projects and Drones should continue to work.
• If using Aura Credits, open Settings → Aura to buy, claim, save your key, and refresh your balance.
• Windows users can install from the latest release installer.
• Source users can update and run with the usual Python install flow.