Product · Changelog

Changelog

Every release, from the first AST commit to today. Aura ships fast and breaks nothing: here’s the whole story, newest first. Open any release for the full detail.

Chapter

Connected to your stack

Aura meets the tools teams already live in: Linear, your own AI cloud, Graphite, Vercel, and the editors you use.

October 12, 2026

In front, and fewer places to look

Panels stopped opening behind the terminal. The terminal is drawn by the graphics card now, which makes it a layer the rest of the window cannot stack against — so nine different popovers had been opening underneath it, and you would click one and get a sliver of a panel instead of a panel. The one people hit most was the small “old aura on PATH” chip in the status bar.
The Create-PR box no longer hands you an empty description at the end of a long branch. It opens on three headings — Summary, Changes, Related Issues — and leaves a description you already wrote completely alone.
The navigation lost the surfaces nobody was using. Tasks is List and Board; Trace is Overview, My sessions and Team activity, with cost and usage now a button inside My sessions. Scribble and the project timeline are gone, and Project health and the code map are switched off — but the doctor, your history in the Time Machine and what the agent remembers are all still there, in one place each instead of two.

FixA popover that overlaps a terminal is drawn in front of it instead of behind: the status bar version chip, both top-bar pickers, the ports popover, all three menus on a cloud box, and the file and people mention pickers.

NewThe Create-PR box opens with a description template — Summary, Changes, Related Issues — offered once, and never written over a description that already exists.

NewTasks is List and Board, and Trace is Overview, My sessions and Team activity. Cost and usage moved into My sessions, keeping everything it does and every link to it.

NewScribble and the project timeline have been removed, and Project health and the code map taken out of the navigation. The doctor command, the Time Machine and the agent’s memory are unchanged.

October 11, 2026

The pane that wouldn’t go away

A pane left holding a tab that was closed somewhere else used to sit in the window as a blank column — nothing in it, no way to close it, shrink it or click into it, and the only way out was resetting your whole layout. Now it tells you the tab is gone and gives you a button to close the pane, and a pane with nothing left to show stops taking up room in the window.

FixA pane whose tab was closed somewhere else says so and offers a button to close it, instead of sitting in the window as a blank column.

October 10, 2026

A terminal that keeps up

Terminals are drawn by your graphics card now, not by the web page around them. Scrolling back through a long run, zooming in and resizing a pane keep up the way a terminal should, and ⌘+ makes the text bigger rather than just the box it sits in. You can switch back to the old renderer if you need to.
Work can start without you. Save a prompt, give it a time or a web address that fires it, and Aura opens the session and gets on with it — with a record of every run. A server that was down when a job was due fires it once when it comes back, not once for every hour it missed.
The models you star become your own shortlist at the top of the model menu, in agent chats and in Aura’s own chat alike, with ⌘1 to ⌘5 on the first five. How hard the model thinks, and whether it answers fast, moved in there too — and the chip now says which of them is on.
Team chat and Pages have come out of the app. The surfaces built on the same data stay: who is working, what landed, and which session did it.

NewTerminals and agent panes are drawn by a native graphics engine by default, and it can be switched off.

NewRoutines: a saved prompt with a schedule or a webhook to fire it, and a row proving each run.

NewThe models you star become an ordered shortlist with ⌘1 to ⌘5, shared by every message box.

NewA workspace can be renamed and can say whose turn it is — and the 201st one is reachable.

NewAn agent can list the projects its key may name instead of having to know one already.

FasterTerminal output stops crossing into the web page as a list of numbers.

FixA screenshot in a transcript opens when you click it.

FixThe summary a compacted run hands itself is no longer shown as a message you sent.

FixA stalled child-process signal can no longer freeze the app.

BreakingTeam messaging, Pages, and support for VS Code extensions have been removed.

September 29, 2026

“Not tracked” stops meaning “could not look”

Aura told some people their project was not being tracked when the truth was that it could not read the project’s settings file. The project was being tracked the whole time. It happens on a Mac that has not given Aura permission to a folder, and for a while after an update — which is to say it happened to people who had done nothing wrong.
Worse, the message came with a button offering to switch tracking on. That button could never have worked: it needed to read the same file that had just refused. Aura now says what actually went wrong, and stops quietly trying a fix it cannot perform.

FixA project Aura cannot read is no longer reported as a project that is not being tracked.

FixAura stops silently retrying a change it has already been refused permission to make.

FixThe hooks and settings panes show the reason a project’s settings could not be read.

September 25, 2026

Work on one project together, without git

Share a session and the other person can open your project’s files from their own machine. No clone, no branch, no remote — they click the link and the files are there, including the work you have not committed yet. One copy of the code and one person writing, so there is nothing to merge and nothing to set up.
Sharing used to hand the other person a window they could only watch. It now hands them a seat: they can drive the session from the moment they join.
A long conversation no longer slows the app down. Aura used to rewrite the whole transcript every time anything changed, so a chat running for hours could hang the window for seconds at a time. It now writes only the new message — on a real months-long session, saving went from a fifth of a second to under a millisecond, and opening it from about a second and a half to a fourteenth of that.

NewA guest reads the host’s project inside a shared session — no clone, no git setup.

NewSharing a session hands over a driving seat instead of a spectator’s view.

FasterA chat saves only the new message instead of rewriting the conversation, so long sessions stay quick.

FixHovering a file an agent linked with a ../ path no longer blanks the app.

FixChat shows when a terminal agent is still working instead of looking finished.

FixA full disk no longer hides the reason the app quit — it writes that line to the system log.

September 19, 2026

Chat that stays in step

In a chat with a coding agent, the message box stretched across the whole window while the conversation above it sat in a narrower column, and a darker strip ran along the bottom. The message box now lines up with the conversation and sits on the same background.
The coding agents’ chats had their own model menu, which looked different and forgot the models you starred. Every chat now opens the same menu as Aura’s own chat, and a model you star is starred everywhere.
If you switched conversations inside Claude’s terminal with /resume or /clear, the Chat view kept showing the old one. It now follows the terminal to whichever conversation it is in.

FixThe message box in an agent chat lines up with the conversation, with no separate coloured strip behind it.

NewOne model menu in every chat, with starred models remembered and shared between chats.

FixA Claude tab’s Chat view follows /resume and /clear in its terminal.

September 18, 2026

One chat for every agent

Aura’s own chat and the chat with your coding agents used to be two different things, with two message boxes, two sets of menus, and a Terminal/Chat switch floating over the conversation. They are one now. Whichever agent you talk to, the message box, the menus, the questions it asks and the plans it shows look and work the same.
Chat and Terminal moved into the session header. Switching between them keeps the session running and keeps what you were typing.
An agent opens in the project you started it in. Starting one takes a moment, and if you switched projects during that moment the new tab used to follow you, so an agent working on one project could sit among another project’s tabs. Now it stays where you started it, and a note offers to take you there.
A tab that belongs to another project names that project on the tab itself.

5 changes in this release

September 17, 2026

Your phone’s choices now reach your computer

The phone app is new from the ground up, and it asks how you want a request handled: make the changes, plan first, or just answer. Until now your computer never heard that part. A request sent as “plan first, don’t touch anything” arrived as an ordinary request, free to edit. Now the choice arrives with the words.
Stop on your phone stops the work. It used to reach your computer as a sentence for the agent to think about. Now the session pauses the same way it does when you press Pause at your desk: the step already underway finishes, and nothing new starts until you say so.
Ask for more careful thinking from your phone and the agent is told to take its time.
You can see which chats are linked to your account and unlink one from your phone. Only the last few characters of each chat are ever shown.
Picking a different model from your phone isn’t available yet. The phone says so rather than pretending: a session keeps the model it started with.

4 changes in this release

September 16, 2026

The console shows the work, not just the words

Open a session in the web console and you can finally see what the agent did, not only what it said. Every file it read, every command it ran, every edit it made, in the order it happened, with the output folded into the step that produced it.
The count at the top of the session was telling the truth about the wrong thing. It said zero tools on every session Aura had ever recorded — not because nothing ran, but because the calls never left your machine. They do now.
Replies stopped running into each other. With the steps between them missing, five separate answers arrived as one unbroken paragraph. Each reply is its own again.
Ask why a file changed and you get the reason someone wrote about it. The lookup was comparing two different spellings of the same path and could never match — on any file, in any session. Every reason already recorded is reachable now; nothing had to be written again.
Your phone stays quiet through all of it. A session’s steps are a record, not a message, so nothing in them can page you or your team.

5 changes in this release

September 15, 2026

Your commits stop carrying your machine

Aura keeps the team’s record in a folder it commits on purpose — what everyone intended, who is on the project, the pages you write. Eighteen files in that folder were not the team’s. They held state only your own computer could know, and every one of them moved on every commit, so half of the diff a teammate opened was your machine talking to itself.
The worst of them was a private key. The file that signs your activity to your team was being committed alongside everything else, in every Aura repository, because the generated ignore list had never named the folder it lives in. It is ignored now, and a repository already carrying it lets go of it on the next commit. A key that is already in a shared history stays there — rotate it.
A rule was never going to be enough. Telling git to ignore a file does nothing to one git already has, and the repositories still churning are exactly the ones set up before the rule existed. Aura now looks at what git is actually tracking and lets go of what does not belong, inside the commit you are already making, and tells you what it dropped. Nothing is removed from your disk.
The team’s half is untouched. The intent log, the roster, the repo identity, pages, taste, goals and per-developer usage stay tracked and stay shared — and two tests now hold both halves of that line apart, so neither list can drift into the other.
Your roster stops reshuffling itself. The team file recorded when each person was last seen, so every commit rewrote it, and it was ordered most-recently-seen first — two teammates trading commits reordered the entire list. It is sorted by name now, and it only gets written when something real changes.

5 changes in this release

September 13, 2026

Stop means stop

Stop did not stop. Clicking it asked the agent to stop and then reported success on having asked — so the session carried on working in the background, still writing to the transcript you were watching, and replies kept arriving from a chat you had ended. Under the terminal daemon, which deliberately keeps running when the app closes, a stop that was never applied left a process nothing could reach any more. Stop now waits for the agent to actually be gone before it tells you it stopped, keeps the tab open when it cannot, and says which of the two happened.
Every agent has a Stop button now. The button was only ever drawn when Aura knew a turn was running, and it only ever knew that on one particular wire — Claude Code’s. Codex, Gemini, OpenCode and Pi had no way to interrupt a turn from the chat at all.
Ending a chat ends it for good. The transcript Aura keeps on disk was filed under the agent and the project rather than the session, and nothing ever cleared it, so the next chat you opened on the same project replayed the one you had killed. That is the part that made it feel haunted, and it is gone.
Escape is tried twice, and the answer is honest. The chat’s Stop used to send one Escape and assume it worked. It now watches for the agent to genuinely go quiet, tries again, and if that CLI simply ignores Escape it says so and puts its own terminal one click away instead of a button that does nothing.
Aura asks, once, for a star. It is free and open source and it had never asked for anything back. There is one screen on first run, one nudge after Aura has actually done some work for you, and permanent links in Settings. At most twice per install, and never again once you answer.

12 changes in this release

September 11, 2026

Aura stops overstating what it knows

Aura had been telling you things that were not true, and most of them had passing tests behind them. A run that stopped was reported as work that finished. A seal, a green verdict and a commit added up on screen to “it works”, which is a claim none of the three makes on its own. The reason you wrote down for a change was quietly replaced by Aura’s guess at it. This release is the sweep through all of it: every surface now says only what it actually knows, and names what it does not.
Recovery no longer costs you what is open. Four different paths reset your working tree, and three of them presented themselves as the safe option while doing it — taking a save point printed a reference that led nowhere and called your work preserved; restoring reset the tree and then told you uncommitted work had been destroyed; a failed orchestration wave reset your own checkout with the error thrown away; and the rollback webhook did the same thing over the network with nobody at the keyboard. All four now anchor your work somewhere recoverable first, and refuse to reset at all if they cannot.
Asking for the reason stopped rejecting the reason. Aura asks you to explain a change before it is committed, and then judged whether your explanation belonged to that change by looking for the function’s name inside your message. So a message that was just “monthly_total” passed, and “round the total to cents so invoices stop disagreeing with the bank” — the exact sentence Aura’s own guidance asks you to write — was refused, and you were told in green to go and write a worse one. An explanation now belongs to a change if it names something that changed, names a file that changed, or was recorded against the files you staged.
A session says whose work it is. Three different voices had been flattened into one, so you could not tell your own words from an agent’s, and an agent that had stalled was described as idle. A session also stops naming itself after whatever command it happened to run, “Resume in app” opens the app, and a page about last Tuesday stops running its buttons against today.
Save points open. Clicking one ran a command that has never existed, so the panel filled with a usage dump instead of your work. They are read from disk now, described in plain words, and the reason you gave is joined back on — and what Aura learns on its own carries where it came from, whether it ever left this machine, and can be taken back from your team.

12 changes in this release

September 8, 2026

The app was closing itself while it was working

Aura had a rescue for a frozen window, and the rescue was the problem. If the app went quiet for a minute the watchdog assumed the window had died, saved your work, and restarted the app. But an app whose window you have closed to the menu bar is quiet for entirely ordinary reasons — nothing is being asked of it — and the watchdog could not tell the two apart. Reading back the stalls Aura recorded against itself over the past week: thirteen of seventeen restarts were of an app with nothing wrong with it. It now looks at what the app is actually doing before it acts, twice over, and steps in only when the window is genuinely stuck.
A talking agent no longer slows the window down. Everything an agent printed was handed to the interface one small piece at a time, dozens of times a second, and on macOS each hand-off costs far more than the few characters it carries — enough that the app could spend its time on the hand-offs rather than on drawing. It is now gathered and delivered once per frame: the same text, in the same order, arriving just as fast to your eye, with the app staying responsive underneath it. This was also the cause of the freezes that were real.
Clicking Aura in the Dock brings the window back. Closing the window leaves Aura running in the menu bar, which is deliberate — your agents keep working. But the only way back was the menu bar icon, so anyone who reached for the Dock found nothing happened, and an app you cannot reopen looks like an app that crashed.
The Code Map tells the story of a feature: it unfolds into the flows that make it work, traced from the code itself rather than from a diagram somebody has to remember to update.
Your project’s parallel copies are back in the sidebar. A project with many worktrees was drawing a single row and a +57 pill, which reads as a project that has none — the list of copies had been sitting behind a condition that was never true. It is in the rail again, and a copy made minutes ago now appears near the top: git records no creation date for a worktree, so ranking them by their latest commit buried a copy cut today off a branch nobody had touched in weeks.
“What Aura did” reads like a person wrote it. The window opened on fifteen rows of machine bookkeeping — tool names, file paths, timestamps — and answered the question nobody was asking. It is three lines of plain language now: what changed, and why.

7 changes in this release

September 6, 2026

A push that lands here and reaches GitHub

Nobody has to leave GitHub for this to work. Until now, putting Aura in front of a repository meant deciding what happens to everything already pointed at the old address — the build that runs on every push, the review tools, the partner who has your repository in their own dashboard. A push Aura accepts is now forwarded to that host by Aura itself, on every push, without anyone being asked to move. Your team pushes to Aura and the place your integrations watch sees the same commits arrive, as they always did.
Who owns a branch is an answer you can check, not a convention somebody wrote down. Ownership of a branch is carried by signatures from the people the team already vouches for, so “who is allowed to move main” stops being a line in a document that nothing enforces and becomes something the machine can be asked, and can answer.
What the project has learned now travels with the name of whoever learned it. A fact shared across your organisation carries the signature of the person or agent that wrote it and where it came from, and the server checks that signature against the key that arrives with it before storing anything. So a colleague’s considered decision reads differently from anonymous prose, and an entry someone tampered with says so out loud instead of quietly passing as true. Alongside it: what kept happening across your sessions gets written down as something the project knows, and the timeline can bring a file back exactly as it stood at a moment you scrub to.
The token claim finally has a number, and it is not the one on the pitch. Aura has said since launch that it saves tokens. A paired experiment over fifty turns — the same questions, asked with Aura and without — found no saving on a typical turn. What it did find is that the worst turns get much cheaper: the runaway question that reads half a repository is contained, and fewer runs fail outright and have to be paid for twice. That is what the documentation says now, in place of the broader claim, and the harness that measured it ships with the app so you can run it against your own repository.
Projects stop disappearing. A crashed index of your open copies of a project could hide them from the list with nothing to explain where they went; there is now a scan that finds them and one click to attach them back, and clicking a project opens it immediately instead of after a pause. The cost report stops reading zero while the real figures sit on disk beside it, restoring an old version of a function uses the history Aura was already computing rather than a second one it was throwing away, and Project Health no longer finishes by running the machine out of memory.

24 changes in this release

September 3, 2026

A lock the locked party could open

An outside audit went through the checks Aura runs on your behalf, and the worst of what it found is in the title. Aura can be sealed in strict mode with a passcode, so that an agent cannot lift the restrictions a person put on it. An agent could lift them. Refused a dangerous command, it wrote down its reason for wanting to run that command — and Aura read the agent’s own note as the permission, so the second attempt was allowed with nobody asked. A note the agent writes itself can never be what opens a lock set against the agent. While the seal is on, a refused act now goes to a person, with what the agent said shown as its argument.
Two more ways a check said clean without having looked. Code you protected could be quietly cut loose: Aura checked that the things on your protect list still existed, which is not the same as checking they still do anything, so a permission check could have its last use removed from the code that called it and sit there untouched, no longer running, while the commit passed. And a whole class of JavaScript and TypeScript file was never read at all — an unread file was skipped rather than reported as unread, so “nothing depends on this” and “nothing was removed” were being said about code nobody had opened. A project written that way was unprotected and told it was protected, which is worse than being told nothing. Both are checked properly now.
The check that runs before you commit stops describing your whole project. Asked about a three-file commit, it answered about every file in the repository — “829 pieces of code look half-finished” — which is why the honest response to it here had become switching it off. It reads exactly what you are committing now, and reads the version you staged rather than whatever is open in your editor, so an unsaved experiment can no longer fail a commit that does not contain it.
Buying Aura works. Every button on the pricing page pointed at an address no version of Aura has ever had, so “Start on Pro”, the trial and the closing Team trial all landed on a signed-in Not Found. And where a payment could be started, it was Pro’s checkout at $20 a seat whichever plan you had pressed — so a team choosing the $40 plan was subscribed to the other one. The buttons reach the right screen now, that screen names the plan you actually asked for, and the old address still works for anyone who bookmarked it.
Four commands that answered confidently about the wrong thing. Aura could not see work you had staged, so staging a change and asking Aura to save it saved nothing at all. Asking why a line reads the way it does gave three guesses when it could not answer, one of them wrong for the commonest case. Asking why a file changed gave an unrelated answer once the file had been renamed, with nothing to say it had guessed. And the smart merge, when it gave up and left the conflict to you, said nothing — so a real disagreement and a file it had never read looked identical. Proving the same goal at the same point in your history gives the same answer twice now, too; it did not before.
The web console keeps closing the gap with the app. Changes now says what changed in each file and by how much, and — this is the part your own machine cannot do — why: what was written about that file during the session, the message of the commit that carried it, and what was said about it in other sessions. A session that sent work out to other agents shows them, who sent which, and what each one reported back. Eleven controls that looked like they led somewhere and led nowhere were found and fixed, including the one button anywhere that starts a payment.
Everyone on a shared machine is now their own person. Work done on a machine several people use was signed by whoever set that machine up, and pushed on their credential — so the record lost the person who actually did it. Each member gets a credential minted for them, which an admin can grant one member at a time and take back the moment they leave. The per-person spend figure works too; it had been reading zero for everybody because nothing was ever writing it down.
Two people can now be in one session, and several copies of one project can see each other’s work in progress while each keeps its own sessions to itself. The phone app is repainted in the desktop’s dark blocks and wears the real Aura mark, rather than a second design that had drifted.

38 changes in this release

September 1, 2026

A frozen window recovers, not a Force Quit

Aura now notices when its own window has stopped painting. It tells you so and offers to bring it back, and the state you were in is kept — so recovering costs you a reload rather than a restart and a lost session.
Sessions you start in a terminal reach the web console now. What you asked for, what changed and the commits it landed all arrive, instead of a session that looked like it did nothing because nothing was ever sent.
A change now names the files its reason was written about. Files were reading "no reason was written about this" while the reason sat right there, unattached — the change and the reason are joined again.
Worktrees stop being filed as projects of their own. A worktree is a view of a project, not a second project, and the picker is the length it should be again.
Every menu in the app is the same menu: one panel, one type ramp, one spinner, shared with the web console. macOS Tahoe stops rounding controls into pills. Settings grows a Team page for the cloud org roster.
The web console at app.auravcs.com is a new app this release. Sessions, changes, machines and git hosting are rebuilt on the desktop app's own surfaces, so a session you open in a browser reads exactly as it does on your machine.

8 changes in this release

August 31, 2026

Every platform ships together again

Linux and Intel Mac were left behind by 0.19.41, which went out for Apple Silicon alone. Everything is back on one cycle: both Macs and both Linux builds are cut, signed and published together, and the download page offers the same version on every one of them.

1 change in this release

August 23, 2026

When macOS says no, Aura says which folder

Aura would refuse to switch on for a project and leave you with an error code and a Try again that could never work. The cause was macOS blocking access to a folder — and Aura had no way to know which folder, and no way to ask for it.
It asks now. Aura checks the folders a project needs before it does anything else, from the app itself rather than through a helper it launches. That check is what makes macOS put up the permission panel at all: a helper cannot raise it, so an app that only ever asked through one was never asking.
And when the answer is still no, the message names the folder. The confusing case is a linked copy of a project: the folder on screen is fine, while the Git folder behind it lives somewhere else entirely, usually inside Documents. The old message said “this folder”, which was true of a folder that was working perfectly.
The button now opens the setting instead of retrying. Full Disk Access is one switch, and pressing Try again before you flip it can only ever fail the same way.
It fixes your coding agents at the same time. Claude, Codex, Gemini and the rest were being refused those same folders for the same reason, and reported it as an internal error.

5 changes in this release

August 23, 2026

Run git on a machine you own

One command turns a machine you own into a git server. aura node serve on any box — a spare laptop, a VM, a server in your office — and your projects live there. It speaks git itself, so anyone can clone from it with the git they already have: no plugin, no account, no Aura required on the other end.
And it can follow a repo that lives somewhere else. Point it at a GitHub or GitLab project and it keeps a live copy on your box, refreshed on a timer. Agents that clone the same project fifty times a day stop hammering the forge and stop running into its limits, and the copy is still there on the day the forge is not.
Every branch that moves on your box is signed as it moves. Each change is written into a running record that carries its own proof, so the record cannot be quietly rewritten later — and if a copy you already have is ever replaced by a shorter history, the next clone says so instead of silently accepting it.
One box can follow another box. Aim a copy at another Aura machine and you have the same project in two places, each keeping its own signed record — a second copy in another building, another region, or another country, without anyone else holding it.
It is free, in every tier, and it always will be. It runs on hardware you already pay for, so there is nothing for us to meter. Your code never touches our servers to make any of this work.
A fix that mattered more than it looked: cloning a project of any real size from your own box failed outright. Git compresses a large request and Aura was reading it as though it had not been, so anything past a handful of branches died mid-clone. Only tiny test projects had ever been served, which is why it went unseen.
The web console has Chat. app.auravcs.com now opens on the same conversation with Aura that the desktop has — same history, same reply, still running on your machine — with a Home/Chat switch in the sidebar and the sessions you have open beside it.
“Online now” stops reading zero. The desktop tells your team it is there, so the people working alongside you show up as working, and the roster says what each of them is on rather than linking away to find out.
What your team spends finally shows up. The cost screen had a server, a table and a page, and nothing that ever sent it a number — so it read $0 for everyone, on every plan, no matter how much had been spent. Every machine now reports what its models cost, and the history that was already on disk is sent up the first time.
The real Aura mark, everywhere. The old flower was still standing in for the logo in about half the product — the tab icon in your browser, the app icon on your phone, and several screens inside the app.

16 changes in this release

August 20, 2026

Your project can say no to an agent

A project can refuse things outright, not just ask. Until now every risky thing an agent did arrived as the same question waiting on a click — which cannot say “nobody here does that”, and only works if somebody happens to be watching at the moment it lands. A new Authority section in your project settings answers three questions once, in writing: deleting something other code may be calling, editing a file a teammate is holding, and sending work off to another machine. Each can be allowed, asked about, or refused, and a refusal cannot be clicked past.
The rules live in the project, in writing. They sit in the settings file that goes into your history alongside the code, so a change to what an agent may do turns up in a review like any other change.
A typo makes an agent do less, never more. An unreadable rule, a missing section or a missing file all fall back to asking, so getting the spelling wrong can never quietly grant something.
Saying yes once means once. These three prompts no longer offer “always allow” — “yes, delete this function” must never quietly become “yes, delete anything”. A standing yes is a rule you write down, where it can be read.
The wall of red “unexplained change” rows is gone. A build or a formatter touching a lot of files at once could fill the screen with things to accept or revert, because Aura briefly stopped recording reasons while it waited out a cooldown. Recording never pauses now, and working out why something changed is Aura’s job rather than a question that interrupts you — the reasons still land in your history, and the check that runs when you commit is unchanged.
Nothing changes until you write a rule. The starting point is exactly what it was.

7 changes in this release

August 18, 2026

A parallel copy opens where you want it

This build was never published on its own. Everything below reached people inside 0.19.39.
A new parallel copy stops assuming you want a chat. Making a copy of a project always dropped you into an Aura chat, which is one opinion about how you work — and the wrong one if you drive Claude Code or Codex from a terminal, or if you only wanted to read the code. Settings → Copies now has a single choice: just the code, an Aura chat, or any agent you have installed, and whatever you typed as the objective is carried into whichever one you pick.
The default changed: a new copy opens the code and nothing else. If you liked the chat it is one setting away, and it behaves exactly as it did.
The choice follows you, not the project — it is the same setting everywhere, because which tool you reach for is a fact about you rather than about a repo. You can change it with no project open at all.
Uninstall an agent and your copies keep opening. If the agent you picked is not on this machine any more, a copy quietly opens the code instead of failing, and the setting tells you why.
An agent’s icon stops looking like it has a stray border. A working agent was drawn with a box around its logo in one of three colours depending on what it was doing; the logo now simply breathes while it works and pulses when it needs you, which reads as status instead of as a rendering mistake.
The web console became a real control plane. app.auravcs.com now has the machines your team can work on, what each person spent, who is in a session right now, and the task and crew board — each as its own screen rather than something buried behind a tab — all on one palette instead of four.

9 changes in this release

August 16, 2026

Committing stops freezing the app, and undo undoes

Saving your work no longer looks like a crash. On a big project the check Aura runs before every commit could sit for nearly two minutes with nothing on screen, and on some machines it stopped forever waiting on a question it had no way to ask you. It finishes in about five seconds on the same project now, and it only asks a question where you can actually answer one — otherwise it decides for itself and says what it decided.
Undo works where you are typing. ⌘Z and ⌘⇧Z had quietly stopped doing anything in the file editor, in Pages and in the chat box, because the Mac’s own menu caught the key first and handed it somewhere that knew nothing about your text.
Links an agent prints are clickable, and ⌘V pastes a screenshot. A web address in a terminal underlined when you hovered it and then did nothing at all; images only went in with ⌃V, which nobody would guess.
A tab tells you one thing, once. A working agent used to be announced three times over — a spinner, a coloured dot and the agent’s own icon — and the yellow dot read like something had gone wrong. The icon itself now breathes while the agent works and wears a quiet ring when it is waiting for you. A tab belonging to another project puts that project’s name underneath, instead of shoving the close button off the edge.
Aura tells you when an agent’s update is stuck. Some CLIs asked to be updated over and over because the update landed somewhere your shell never looks; Settings → Agents names the copy that is actually running, the one that is hiding, and what to do about it.
We count a little more of what happens in the app — counts and flags only, never your code, your prompts, your file names or your project paths. Anything that even looks like one of those is now thrown away before it can leave your machine, so a future mistake cannot leak one. It stays off unless you said yes.

7 changes in this release

August 12, 2026

A computer your whole team can work on — and Aura can make it for you

Your team can share a computer to work on, and only one person ever has to set it up. An admin names a place, picks a size, and Aura makes the machine — or points at a box you already own. Everyone the admin lets in signs in and starts working there: no keys to copy, nothing to install, no wizard.
The two kinds of machine behave the same, deliberately. Anything you can do on a box you built yourself you can do on one Aura made, and the other way round. There is one honest difference: Aura can only put a machine to sleep if it is allowed to start and stop it, so a box you own and run yourself stays on until you say otherwise.
Sharing a machine no longer means sharing an account. Each person gets their own login on the box, their own tools, their own agent credentials and their own share of the machine, so one person’s build can’t starve everyone else’s. A commit made on a shared machine says who made it, instead of being signed by whoever set the box up.
Push as yourself. Aura can mint a short-lived credential just for you, borrow the key already on your laptop for the length of the connection, or use a token you’ve stored — and it always says which one it is using, so a credential everyone shares is labelled as one. GitLab, Bitbucket and your own server work too, not only GitHub.
Your project’s setup gets built once, not once per person. A project declares what it needs and every place becomes that, so the second person to arrive starts from what the first one built. Need one tool just for yourself? Install it for yourself, without root. And a machine will tell you what it actually has against what the project asked for, so “works over there, not on mine” is a list rather than a mystery.
Two at once, side by side, in one window. Open a second project — or a second machine — without losing the first: tabs, open files and terminals all stay where you left them on both, and either one can pop out into its own window. Entering a machine used to empty everything else out of the app.
Pick which team you’re acting as. In more than one? Switch without signing out, and each shows its own projects and machines with your personal work alongside. An admin turns cloud on one person at a time, only members reach the team’s machines, and removing someone removes their reach. You can see what you spent, separately from your teammates.
Aura can read the web, and says what each answer cost. Ask it to check a page or the docs for something you’re integrating and it will go and read it. On your own API key, every answer shows what that answer cost and the meter shows the total since you added the key.

16 changes in this release

The cost meter, on its way to 0.19.36

This build was never published on its own. What it carried — a running count of what each answer on your own API key costs — reached people inside 0.19.36, and is described there.

One way around the app, and it stops telling you things it never checked

There is one way around the app now. Every destination (your work, your team, your pages, your history, your parallel copies) opens the same way, in the same place, with one row of tabs across the top instead of two and one bar of chrome instead of three stacked on each other. Clicking a destination takes you to it; several of them used to only light up and leave you where you were.
The app stopped claiming things it hadn’t looked at. This is the biggest single sweep in the release: a review that said “all clear” having read half the evidence, “no secrets found” from a scan that never ran, “your project’s in good shape” over problems it had already found, “Verified” printed over a proof that said the work was never wired up, a clean working tree reported when the check had failed, and a dozen lists that told you they were empty before they had read anything.
It is much faster to open and to move around in. Sixteen panels used to ask the same question separately; now they ask once and share the answer, and the same is true of your team, your history, your crew and your tasks. Reading your most recent checkpoint used to read every checkpoint you had ever made: gigabytes, every time.
Your work has one home. Tasks is the place: the board, your loops and your goals on one rail, with Mission Control as two lenses of that same work rather than a second app with its own statuses.
Team is the team. Real names on messages instead of logins, one rule for who’s online, direct messages that list people as people, and drafts that survive leaving a conversation.
Run your project from the terminal with ⌘R: one command per project, remembered, and it never guesses what to run.
An agent’s conversation no longer loses what happened while you were looking elsewhere. Switch tab and come back, and everything written in between used to be gone for good. It’s all there now, and it always was: the app simply wasn’t going back for it.
Aura works in your language. Twelve places crashed outright on text that wasn’t English: a name, a message, a filename. Long text now cuts where you can read it rather than through the middle of a character, and dates say which year.

14 changes in this release

Every copy of your project in one place, and a commit that has to match what you asked for

See every copy of your project at once. When several things are being worked on in parallel, each gets its own copy, and until now they were easy to lose track of. Workspaces lists them all: what’s unfinished in each, how far each has moved from your main line, and who or what is working in it.
Agents in different copies stop colliding. Aura now watches every copy of a project together, so when two agents are about to change the same thing in different copies they find out before it happens instead of after. What’s inside each copy still stays private to that copy.
A commit now has to match what you said you’d do. Before work is committed, Aura compares it against the intent behind it, and if the two disagree it stops and shows you the disagreement rather than letting it through quietly.
If something you asked to keep was rewritten anyway, Aura names it. It won’t block the commit, the piece is still there, but nobody gets to rewrite something you’d protected without you hearing about it.
Undo now reaches things that were deleted, not just changed. Rewind could already put back a piece that had been rewritten; it can now bring back one that was removed outright.
The newest models are in the picker, Opus 5 at the top. Claude’s 5 line (Opus 5, Sonnet 5 and Fable 5) sits above the older ones wherever you choose a model, and a fresh install starts on it rather than last year’s. If you’ve already picked a model yourself, yours is kept.
Starting a new copy of your project now opens Aura, with what you asked for already in it. You’d type what you wanted, watch the setup steps run, and land in a bare coding tool with your message nowhere to be found. It was being typed in for you the moment that tool started up, and it often got there too early to stick. Now the new copy opens in a conversation with Aura, your request already sent, on whichever model you picked.
Every agent you have running shows up when you open a new tab, whatever project it’s in. The “jump to something already open” list only knew about the project you were looking at, so an agent working elsewhere, or in a separate copy, was invisible until you switched over to find it. They’re all listed now, each with its project and a dot showing it’s still running.
Turning Aura on works in every copy of your project. In a separate copy it used to fail every time, and because the reason was thrown away, “Aura is off” sat there with a Retry button that did nothing. It works now, and if it still can’t, it tells you why in plain words.
When Aura hands work to several agents at once, you can see them, and their answers come back. Aura would say it had started two agents and then show you nothing, because saving the conversation wrote over its own record of them. They were really running; nobody could see them, and when one finished there was nothing left for its answer to return to, so ten minutes of work was quietly thrown away. Both are fixed.

21 changes in this release

Every change explained in plain English, and a feature you can read at a glance

Every change now says what it does, in plain English. Beside each edit you get what the code used to do, what it does now, and why, on both sides of the comparison, so you can follow the work without reading the code.
Read a feature at a glance. Confidence, Risk and Drift over anything you set out to build, gathered from every session and commit that touched it, including where an agent said one thing and did another.
“Is it actually finished?” is now checked against the version the agent was working on, not whatever you happen to have open. Switching branches can no longer report a false zero.
Nothing gets deleted quietly. If a commit removes something nobody accounted for, Aura stops it, names exactly what went missing, and tells you how to explain it.
Ask Aura anything about your project from ⌘K and get a straight answer, drawn from what actually happened in the repository.
Scribble: a shared notepad that lives in the right rail. Anything you don’t finish today rolls over to tomorrow.
Your task board now sits inside Team, right next to the conversation about it.
Aura for iPhone and Android is coming. Join the waitlist from Settings → Connections. It goes straight to us, not to a form host.
Carries everything from 0.19.31, which was built but never published, so updating from 0.19.30 lands you here with both.

17 changes in this release

Steer with a tap, pull one agent out, and a Team that tidies itself

This build was never published on its own. Everything below reached people inside 0.19.32.
Steer an agent with one button. While it’s working, tap Steer, or press ⌘↵, to change course, and your new direction lands right away instead of waiting for it to finish.
Pull a single agent out of an Aura chat in one tap. “Take {name} out” hands you its own session, and that same session shows up in your terminal, so you can carry on there too.
Your Team list tidies itself. When one person turns up twice (a work email beside a personal one, a display name that matches their GitHub handle) Aura quietly offers “Same person” to fold them into one. Nothing merges without your say-so, and “Different people” makes the hint stop for good.
Let Aura open your pull request. When there’s no PR yet, one tap has Aura commit, push, and write a clear title and description from what actually changed: no blank form to fill in.
New here? A ready-made sample project greets you on first launch, and the Get-started tour now speaks to people who already build with agents: less “what is an AI coder”, more what makes Aura different.

14 changes in this release

Steer a working agent, browse your Pages, and a cleaner Team view

Change course mid-task. While an agent is working, send a follow-up and it redirects right away instead of waiting for it to finish.
Pages now work like a browser: back and forward arrows to retrace your steps, and every page opens instantly instead of reloading from scratch.
The Team view reads like a real conversation now: activity grouped into plain-language threads, a tidier member list, and cleaner headers.
Nicer editing: code blocks are clean and colour-coded with a language picker, and Undo (⌘Z) works again in the file editor.

7 changes in this release

Start new work on your always-on cloud machine

When you start new work, pick where it runs: Local keeps it on this computer; Cloud hands it to your always-on machine so it keeps going after you close your laptop.
Not set up for cloud yet? A one-tap “Set up cloud” signs you in, then the same button sends your work to the cloud.
Cloud shows a quick status: green means a machine is ready and your work starts right away, amber means it waits in line until one comes online.

3 changes in this release

Files open properly, and dropped screenshots land

Open a file and you’ll actually see it. On some setups a file could open to a blank page: now the text shows every time, whatever the file.
Drag a screenshot into the terminal or a chat and it lands where you drop it, instead of quietly going nowhere.

2 changes in this release

Opened folders stay in your sidebar

Open a folder and it stays in your sidebar, even when your recent list is already full, so a project you just opened never quietly disappears.

1 change in this release

A companion on your menu bar — and your phone in the loop

Meet your desk-pet: a tiny companion on the menu-bar HUD that reacts as your agents think, run, and finish.
Pair your phone with a full-screen QR code, then see your laptops, live sessions, and past work in the Aura mobile app.
Launch an agent and land straight in its chat, and your chat history comes back exactly where you left off.

6 changes in this release

Your tools, your cloud, your deploys

Plan in Linear? Connect it the same way you connect Jira: your issues flow straight onto the board.
Use the AI account your company already pays for. Aura now runs Claude through Amazon Bedrock and Google Vertex, and works with Azure OpenAI.
See your work ship. Stacked pull requests read as a stack with Graphite, and a change shows as building or live on Vercel: right on the pull request.
A new “Open in…” jumps straight to your favourite editor, and Settings got a cleaner, more compact redesign.

6 changes in this release

More agents, less setup

Bring the coding agents you already use. One-click onboarding for Codex, plus ready-made presets for Antigravity, Aider, and Amp.
Pin the agents you reach for most so they’re always at the top.

4 changes in this release

Chapter

Hardening

Security, trust, and a surface locked down for real teams.

Private team rooms

Team rooms now have real membership: invite people in, and only members can read the room.
Lost access? Offline recovery codes get you back in without waiting on anyone.
Shipped to all four platforms in the same cycle and delivered by silent auto-update.

3 changes in this release

Calmer errors

When the AI engine hits a problem, Aura now shows a clean, plain-language message instead of a raw error dump.

1 change in this release

One you, everywhere

Signed in two different ways? Aura now recognises it’s the same you and merges the accounts into one: your history, ownership, and messages stay intact.

2 changes in this release

Security hardening

Closed several security gaps across team chat, live sync, and sign-in: after a full end-to-end security review.
Tightened what the desktop app is allowed to load from the web. Your messages and your team stay yours.
Shipped to all four platforms in the same cycle, macOS (Apple Silicon + Intel) and Linux (arm64 + x86_64), and delivered silently by auto-update.

3 changes in this release

Chapter

The desktop app

Aura becomes a place you live in: chat, crew, tabs, and a memory that carries forward.

Agents always start in the right project

Starting an agent never reopens a conversation that belonged to a different project, or an older copy of your work.
Cross-platform packaging fixes so every build ships for the architecture it claims.

2 changes in this release

Turn the floating Aura on or off

Don’t want the ⌘⇧A floating window? Switch it off for good in Settings → Floating HUD, and it stays off after a restart.
Closing an agent or terminal tab now actually stops what was running inside it.

4 changes in this release

A floating Aura you can call up anywhere

Press ⌘⇧A from anywhere to pop up a small always-on-top Aura window: glance at your agents and fire off a message without switching apps.
Every tab now has a ⋯ menu right before its close ×: split beside or below, add to a split, rename, or close.
The floating window lives in your menu bar too and follows whichever project you’re in.

2 changes in this release

A split before/after diff beneath a WHY IT CHANGED header, with the changed-files list docked at the right.

Chat sessions show what changed — and check their own work

Open a chat session and see exactly what it changed (every file, before and after) instead of an empty list.
When a chat session changes your code, Aura checks it against what you asked, on its own.

3 changes in this release

Auto stays on Auto — and Retry gets back to work

Auto mode no longer drops you into planning and forgets to come back. It stays on Auto so your next message just runs.
Hit “Retry” on a crew task and it gets to work right away instead of sliding back into the queue.

2 changes in this release

The Runner view showing crew progress, a crews sidebar, start-able goals with ready counts, and past runs.

A crew that recovers on its own

When a crew hits a snag it gets itself unstuck: falls back to whichever AI you have installed, saves files an agent forgot to commit, and still merges finished work back through unsaved changes.
Put failed work back in motion with a single “Retry”, or “Retry all” at once.

2 changes in this release

Tabs that stay put, projects in their own window

Your tabs reopen exactly as you left them: same order, same one open.
Open any project in its own separate window, so you can keep two side by side.
Reopen a past chat and pick up right where you left off with “Continue chat”.

3 changes in this release

The Team surface: channels and direct messages at left, an Aura chat with engine tabs and starter prompts.

Your chat name is your GitHub username — everywhere

Team chat shows you under your GitHub username on every project, instead of a slice of your email.
Your name stays the same across machines and projects, even when you commit under different email addresses.
Still no sign-in needed: team chat works free the moment you open a project.

2 changes in this release

A Pages document with a how-we-work section and a definition-of-done checklist, next to the Pages tree.

Redesigned Pages, per-project identity, instant assignment DMs

Pages got a cleaner redesign: your notes and docs are easier to read, write, and find.
Tell Aura which teammate is you on each project, so work is credited to the right person.
Get a direct message the moment someone assigns you a task or mentions you.

4 changes in this release

Linux, on Arm

A full Linux desktop channel: AppImage with the same silent auto-update as macOS, on both arm64 and x86_64.

1 change in this release

The Workspaces rail of repos, branches and parallel copies beside a chat composer and engine tabs.

Snappier history, one-click workspaces, tidier tabs

Opening your sessions and activity history is near-instant. It no longer re-reads everything each time.
Click a workspace and land straight in a working view; its main copy is always right there.
Right-click any tab (file, chat, terminal, or agent) for the same split / rename / close menu.

3 changes in this release

A session continued on Gemini, ending with a work report that cites the files and commits it changed.

Switch AIs mid-chat without the thread breaking

Switching from one AI to another mid-conversation stays seamless: Aura keeps each one’s words straight.
If an AI hits its limit or stumbles, Aura quietly continues on another so your conversation doesn’t stall.
Your direct messages stay strictly between the two of you.

2 changes in this release

Fixes for files, agents, and switching models

Switching the model, say Claude to Gemini, now actually takes effect for the rest of the chat.
New files and folders land in the folder you’re working in, and you can drag a file onto a folder to move it.
Reopening a past conversation tells you at a glance whether it’s an Aura chat or a Claude Code session.

3 changes in this release

A goal decomposed into a dependency graph feeding design and build wave nodes, with a result bar.

Understands your code, and a crew you can watch

Aura grasps your code without reading whole files, and each reply shows roughly how much it saved.
When a job needs several agents at once, Aura runs them as one coordinated crew, with proof when each piece lands.

3 changes in this release

Snappier chat and friendlier copies

Chat no longer gets stuck on “Loading…”, even very long conversations open right up.
The copies an agent works in show a friendly name instead of a machine code.

2 changes in this release

Five kanban lanes of task cards assigned to agents, with a Run-crew control.

Faster, calmer, and it remembers

Aura now remembers what it learned across sessions, so it picks up where you left off instead of starting cold.
Plans you can accept and questions Aura asks stand out clearly in chat: no more hunting for them.
The mode you pick (Auto, Plan, or Ask) sticks for the whole conversation.
Hand Crew a stack of tasks and it works through them on its own, showing proof each one did what it set out to.

4 changes in this release

Chapter

Toward a desktop

Unified versioning, signed semantic refs, and peer-to-peer collaboration.

A channel feed of signed events tagged INTENT and COMMIT, with branch and state chips.

Memory, signed refs, and a smarter merge

The first foundations of agent memory land in the core.
Semantic references are cryptographically signed, and merges resolve at the syntax-tree level.

3 changes in this release

Silent updates, trusted binaries

The CLI updates itself silently in the background.
macOS binaries are signed and pass Gatekeeper cleanly.

2 changes in this release

One version, everywhere

A single unified version across the CLI, desktop app, cloud, and every crate.
The desktop app enters beta.

2 changes in this release

Mothership: peer-to-peer collaboration

Teams share semantic state directly, peer to peer: the first collaboration layer.

1 change in this release

Chapter

The semantic engine

The CLI and the AST core the whole thing stands on.

Sentinel Auto-Reply & Cloud Production

Agents auto-reply to unread messages when their session ends
Snapshot guard: warns when files are modified without a snapshot
Unread messages shown inline at session start (BLOCKING)
AI-powered memory compaction (open-source)
Cloud: trial periods, usage metering, Stripe idempotency

10 changes in this release

A why-this-changed header reading “rewrote one function and one constant” above an old-versus-new split diff.

Semantic diff & rename-proof identity

A true semantic diff: see the logic that changed, not the text lines that moved.
Rename-proof node identity: a function keeps its identity through a rename.

2 changes in this release

Duo Mode & Symphony

Multi-agent orchestration: run Claude Code and Gemini CLI in parallel
Linear-driven AI development workflows
TOON encoder for 30-60% token savings on MCP responses
Durable file snapshots: your work is never lost

11 changes in this release

February 14, 2026

A side-by-side diff on the Files tab next to a column of Aura review comments flagging validation and naming.

The Governance Update

High-fidelity semantic PR review engine
Dev Metrics dashboard with real-time AST visualization
Rename-proof logical node identity and diffing
148 features across CLI, MCP, API, and Dashboard

10 changes in this release

January 18, 2026

The Intelligence Update

MCP Server with 16 tools for AI agent integration
GSD Orchestrator for wave-based execution
Continuous semantic tracker daemon

8 changes in this release

December 8, 2025

The Intent-to-AST view placing the stated intent beside the real syntax-tree changes it produced.

The Foundation

AST Merkle-Graph with tree-sitter parsing
Surgical rewind for function-level rollback
Intent verification via pre-commit hooks

7 changes in this release

December 2025: the first AST commit