What changed, and when

*August 2026*

Atlarix Core comes with Pro, and the app finally says so. Pro includes Atlarix Core for everyday

work, but the app still spoke as though a plan was the thing standing between you and a model —

running low on credit offered to sell you an upgrade you may already have had, and a third-party

provider's own free-tier limit suggested buying Atlarix Pro, which would not have helped at all.

Every message about money now comes from one place and talks about your balance rather than your plan.

You can see which half of your balance expires. Settings shows what is included this month

separately from credit you bought. The included part resets when your plan renews; credit you paid

for never expires.

A refunded month is actually a refunded month. Refunding a subscription used to leave the plan

active and the included usage sitting in your balance, because the app was never told about it.

Refunds now end the subscription straight away and return the usage that came with it — the part you

have already spent is not chased, reviews already posted are not withdrawn, and credit you bought

separately is never touched. Partial refunds return a proportional amount instead of everything.

Browser tools work on a local dev server with the panel closed. Pointing the agent at

localhost did nothing useful until you opened the right panel by hand: the page was being loaded

into a browser view that had never been given a size, so it laid out at zero width and every answer

the agent got back about it was wrong in a way that looked plausible. The view is now always sized,

and the panel only decides whether you can see it.

A small "what's new" note. The bottom-left corner tells you what changed after an update,

without opening a browser.

*August 2026*

Deep thinking works on Atlarix Core. The toggle was missing for every Core model while the same

model on your own API key had it — and underneath that, it was reaching the provider for neither.

Atlarix now asks each model what reasoning control it actually supports and sends that control on

every route, so turning Deep thinking on genuinely asks for the model's maximum instead of changing

nothing. On Core it also stops asking for one notch less than the model offers.

Web search finds what you asked for. Searches were being cut down to six keywords before they left

the app — an exact phrase in quotes was broken apart, an author's name at the end was dropped, and what

reached the search engine was a fragment. Deep search made it worse by always searching developer sites

and ranking ordinary web results last, so asking about a book returned programming pages. Searches now

go out as written, deep search looks where the question points, and a search that found pages can no

longer come back empty because a relevance filter disliked all of them.

You can see how much the agent has written for you. Your profile now shows lines added and removed

per project, which model did the writing, and a contribution calendar of your daily activity. It tells

Atlarix Core apart from the same model on your own key, and it counts what was actually applied —

including when you accept only some hunks of a change. It records edits the agent makes through its

file tools; changes made by commands it runs are not included, and the card says so. Everything stays

on your computer.

Tool cards stop showing each other's results. When the agent ran two searches at once, one card

could display the other's results while the other reported nothing found. The searches themselves were

always correct and so was the agent's reading of them — only the transcript was wrong, which made it

look as though the agent had invented an answer. A search that genuinely finds nothing now says which

query came up empty instead of just "Done".

The work-mode chip tells the truth. It could show one mode while the picker beside it showed

another, and Shift+Tab announced a mode change that never took effect for sessions with their own mode.

Both controls now read and write the same place. A turn keeps the mode it started in, so while one is

running the chip shows the mode that turn is actually using and the picker marks your new choice as

applying to the next message.

*August 2026*

There is a Diagnostics screen now. Settings → Diagnostics checks the things that fail quietly:

your account and Core balance, every API key you have saved, the model catalogue, the OS keychain,

search, the terminal, the local database and the command sandbox. Every row that fails tells you what

to do about it. Your keys are checked by asking each provider for its model list — never by generating

anything — so running diagnostics cannot cost you money. "Copy report" gives you something safe to

paste into a support message, with keys, tokens, email addresses and file paths stripped out. If the

app will not open far enough to reach Settings, the same checks run from a terminal with --doctor.

Debug mode does the full job now. Debug has always had the same tools as Build — the difference

was meant to be how it works, not what it can do. Internally it was being run like a read-only mode:

one pass per turn, skipping the checks that make Build finish what it started. It now works like

Build, while still behaving as Debug.

A database error tells you what will actually help. It used to say "Please restart the app", which

was the one thing guaranteed not to work — Atlarix had already retried before showing you anything. It

now names the cause and offers to download the current version or show you the logs. It also

recognises when your data came from a NEWER version of Atlarix than the one you are running: nothing

is damaged there, and nothing needs deleting.

Each conversation remembers its own mode. Plan in one session and Build in another used to be

impossible — the mode was one app-wide setting, so reopening a session you had been planning in could

quietly start writing files. Sessions now keep their own.

Answers stop cutting off mid-sentence. Some providers report a failure by returning a normal-looking

response whose ending reason is the error. Atlarix treated those as finished answers; it now retries.

Less memory with several sessions open. Switching away from a conversation frees what was being

held to draw it, and switching back reloads it. Anything still streaming is left alone.

Skills on the Free plan. Clicking Skills opens the Skills screen and explains that installing

Agent Behaviours needs Pro, instead of throwing you into a payment page. Project instructions and

behaviours committed to your own repo keep working on Free.

*August 2026*

Web search works again. If you use Atlarix's own AI (Core) and asked it to search the web, it was

very likely finding nothing — not fewer results, none. The free services it fell back on have quietly

stopped being usable for this: one only ever returned encyclopaedia summaries rather than search

results, and the rest now refuse requests that don't come from a real browser. Atlarix *is* a real

browser, so it now searches with the one it already ships, invisibly and in the background. On three

ordinary programming questions that previously returned nothing at all, it returned 24, 29 and 25

results. This is not the AI browsing on your behalf and it never opens a tab you can see — it is the

search underneath, doing what it always claimed to.

Setting up search is no longer something you can do wrong. The old settings page walked you

through installing a search engine in Docker — a whole flow, for a fallback that measurably returned

nothing. It's gone. Search needs no setup at all now. If you run your own search server there is a

single field to point Atlarix at it, and it checks the address actually answers before saving.

And it can read pages that need a browser to make sense. Asking Atlarix to read a specific page

used to fetch the raw file and nothing more, so a modern site that builds itself after loading came

back as an empty frame, and a site that screens out non-browsers came back as a refusal. It now tries

the quick way first and falls back to actually rendering the page when that returns nothing useful —

so documentation sites, dashboards and anything behind a bot check read properly.

Signing in with a passkey no longer hangs the page. If a site offered you more than one saved

passkey, Atlarix's browser had nothing listening for the question — so the page just waited, for ever,

which read as the browser being broken rather than as a feature being unfinished. Later it refused

outright, which was worse: a security key holding two credentials could never be used at all. Now it

asks which account you want, and a security key with several credentials works.

And when a site asks for a passkey Atlarix can't provide, it tells you what will. A site asking

specifically for a passkey *stored on this device* can't be satisfied in Atlarix's browser. Instead of

a silent wait you get a note saying to choose "use a phone or tablet" and scan the QR code with the

device your passkey is on, or to use a security key — both go through the browser normally, and the

passkey on your phone is the same one you set up elsewhere.

The Plan panel says which plan it is showing, and lets you switch. A session can hold several

plans, but the panel only ever showed the newest one — so one plan was presented as though it were

*the* plan, with nothing on screen saying the others existed.

Steps now stay ticked. Marking several plan steps done at once could silently lose most of them,

and marking one could be refused outright when its text contained formatting. On a long task Atlarix

also worked in several passes and was handed the step counts from the *beginning* of the task at the

start of each new one — so it could tick three steps, then immediately be told only one was done, and

start arguing with a stale number instead of carrying on. All of that is fixed.

A large amount of dead machinery is gone — about 30,000 lines. Atlarix began as a fork and had

been carrying whole features nothing could reach: a hosted AI gateway pointed at a server that no

longer exists, a project-details screen with no way in, a visual editor for a preview pane removed

several versions ago, and a container mode no setting could turn on. None of it was reachable, so

nothing you use changes — but a "Refresh app" button that did nothing, and an "Atlarix Pro" toggle

wired to a dead server, are no longer there to click.

Under the hood: the browser is five Chromium versions newer (two of the versions Atlarix shipped

on had gone end-of-life, so it was serving an unpatched browser), on-device dictation now runs under

the app's security policy like everything else, and a dependency and security pass took known

vulnerabilities from 54 down to 28.

Accounts can be suspended. If an account is suspended, Atlarix says so plainly, points to

support@atlarix.dev, and offers to sign out — it doesn't fail with a confusing error or pretend to be

broken. Nothing here affects anyone whose account is in good standing.

---

*August 2026*

Atlarix can now check its own work. After building something, it can send a tester at the running

app — one that gets the requirement and the URL but deliberately *not* the code that was just

written, because the surest way to miss a bug is to test the thing you designed. The tester drives a

real browser and runs real commands, and it cannot change anything: no file edits, and its commands

are confined by your operating system to reading only. So it can run your test suite and hit your API,

but it cannot touch your project.

It reports what it saw with the evidence — a status code, a console line, a log excerpt. Finding

nothing is a real answer and it is allowed to give one; *"tried these three things, all worked"* is a

complete report. "Broken" and "couldn't get to it" stay separate, because they need different things

from you. Everything it reports, Atlarix reproduces before acting on it.

Two windows no longer fight over one mode. If you had Atlarix open on two projects, the second

window could quietly put the first one into read-only mid-task — so a command that should have

written failed, while the first window still showed Build. It read like a broken repository and

was nothing of the kind. Each conversation now keeps the mode it started in, from beginning to end.

Stop now stops, even when Atlarix is waiting on you. When it asked permission to write outside

your project — where it keeps its notes about a project, for instance — the request would wait for

your answer, which is right. But pressing Stop did nothing to that wait, and answering much later

still went ahead. That wait is also easier to spot now: it shows the same amber timer a long-running

command gets, and says which folder it is asking about rather than just "1 approval waiting".

"Allow all" means the rest of the turn. It used to clear only the requests on screen at that

moment, so the next command asked again — and on a task running several tools in a row you ended up

clicking it over and over. It now covers everything that task goes on to ask for, and still saves no

permanent rule: it ends when the task ends.

• Long command output stopped being thrown away. When a command produced more than Atlarix could keep,

it was keeping about thirteen lines of it — and shuffling what survived out of order. It now keeps

as much as it can, in the order it happened, and tells you how much it skipped.

• Plans keep the name Atlarix gave them. Most plans were showing up as "Goal" because the real title

was being discarded and a section heading used instead.

• Removing a workspace no longer warns about deleting files when it isn't going to. It says what it

actually does — the project comes off your list, and nothing on disk changes.

• Atlarix uses fewer tokens per message on tool instructions, which leaves more room for your actual

work, with no loss of what it can do.

*August 2026*

Your automations were running and telling nobody. If an automation was set to notify Atlarix,

it ran on schedule, added its row to the feed and sent its notification — and Atlarix never heard

a word. The result was being recorded correctly the whole time; nothing was picking it up. So the

next time you opened that project and asked a question, the finished run was simply missing from

what Atlarix knew about.

That was the worst kind of silence, because everything you could see looked fine: the run

happened, the feed updated, the notification arrived. Only the part you couldn't see was broken. A

finished run now reaches Atlarix on your next message in that project, exactly as background

commands and sub-agents already did.

Automations still never interrupt you. A finished run waits for the next thing you ask rather than

starting work on its own — an automation can't decide to spend your credits while you're not

looking, which is what the *notify Atlarix* switch has always been for.

Atlarix can now run an automation on demand. Ask it to try the automation it just set up and

it fires that one immediately instead of waiting for the schedule, so you find out it works now

rather than tomorrow morning. It behaves like any other command: quick ones report back right

away, slower ones carry on in the background and tell you when they finish. You always get the

result of a run you asked for — even for automations set to notify only you.

*August 2026*

A scanned PDF is now readable. Attached PDFs were always converted to text on your machine,

which works for a text document and produces *nothing at all* for a scan or a photographed page —

the assistant would simply tell you it couldn't read it. Models that accept documents natively now

receive the PDF itself, so scans, tables and multi-column layouts come through. If your model

doesn't take documents, the text extraction runs exactly as before.

Stopping a command actually stops it. Every command runs through a shell, so pressing stop only

ever signalled the shell — and whatever it had started kept running. Cancel a dev server and the

server stayed up, still holding its port, while Atlarix reported it stopped. The whole process tree

is now taken down, including when you quit the app.

"Always allow" now means it. If the assistant queued several file changes at once, choosing

*Always allow this file* / *this folder* / *this extension* on one of them left all the others still

asking. It now clears every queued change the new rule covers, and tells you how many in one line

rather than another pile of cards.

Approvals no longer scroll out of sight. A bar above the message box shows what's waiting for as

long as something is, so a long task can't bury the approval you're being asked for. The diffs stay

in the conversation — *Review* jumps you to them.

Two windows no longer trip over each other. With two windows open — even on completely different

projects — a background command finishing in one could restart the task running in the other, over

and over, until the app froze. Multiple windows, multiple projects and multiple concurrent sessions

now work as intended, and pressing Stop is respected across all of them.

• The browser panels hand things over properly. Sending Console or Network output to chat now

arrives as a named attachment instead of pasting hundreds of lines over what you were typing. And

each page load gets its own card: a tab you'd navigated from one site to another used to show a

single card, titled with the newer site, containing both.

• Finding a workspace. Past five projects the Recent workspaces list gains a search box and

scrolls — searching names and paths, so two checkouts of the same repo are still tellable apart.

• Reopening a session no longer hijacks the side panel. It used to jump to the Plan tab and force

the panel open. The plan still loads and the tab now shows a dot instead.

• Reading the same page twice in one task now costs one fetch, for 15 minutes.
• Better recovery when an edit doesn't apply, so the assistant stops re-typing indentation and

looks at the real difference instead.

*August 2026*

**Atlarix's built-in browser now shows you every request a page made — and it has stopped deciding

on your behalf that something is broken.** The two changes go together: the second is what made the

first worth building.

Nothing the browser sees can end a task any more. Until now, a failed request or an error in a

page could stop Atlarix from finishing and push it to go fix whatever it found. The trouble is that

it cannot tell *whose* error it is. A front end on one port calling its own API on another is one

app across two addresses. A staging site is the app you are testing. An embedded payment script is

someone else's code right up until the day it is yours. Any rule we could write is wrong in one

direction or the other — and it went wrong in the costly direction: Atlarix opened YouTube simply to

read it, Google's signed-out login check returned an error, and Atlarix was told to go fix a

third-party sign-in handshake. It refused, correctly, and then spent turns arguing with something

that could not hear it.

So it is told now, not blocked. One line — what happened and where to look, never the contents

— and it goes and reads the detail itself if it judges the detail matters. Settings → Browser

decides what it hears: everything recorded, only failures, or nothing.

• A Network tab. Every request each browser tab made: method, status, type, how long it took and

how big it was, with headers and response bodies when you open a row. One scrollable card per tab,

so what one site did can never be read as what another did. Bodies are fetched only when you ask,

and if the browser has already discarded one the tab tells you so instead of showing you an empty

box.

• You choose what Atlarix looks at. *Send to Atlarix* on a single row, a whole tab, or everything

on screen — it lands in your message box behind a separator, so it never eats what you were

already typing. Unread counts on Console and Network let you know something arrived without

interrupting you.

• The Console tab groups by tab too, with a divider marking where the page moved on. Navigating

no longer wipes anything — comparing two page loads is often the entire point.

"Restoring your session…" no longer hangs forever. If Atlarix started while you were signed out,

that message could sit there indefinitely with no way past it. It now resolves, and tells you if it

is taking longer than usual.

A crash on Linux. Desktop notifications could take the whole app down with them. Fixed.

Behind the scenes: retries no longer all arrive at the same instant, and background helpers start

staggered so they share work already done instead of each repeating it.

*August 2026*

**If you pressed the mic for free on-device dictation and it just span forever, this is the

release to install.** Atlarix can run speech recognition two ways: on your graphics card, or on

your processor. The processor path had never worked — not on Windows, not on Linux, and not on

macOS either. Macs simply never used it, because their graphics path works. Any machine without

a usable graphics path fell straight onto the broken one, every single time, and nothing could

recover from it — so restarting the app made no difference.

• One download instead of two. Falling back from the graphics card to the processor used to

fetch a completely different set of model files, so an affected machine downloaded roughly

800 MB before showing you an error. It is now about 285 MB, once, shared by both.

• The mic works while the model downloads. It used to be a greyed-out spinning icon for the

whole download — you could not click it at all. Start talking straight away; your words appear

once the model finishes loading.

• Honest progress. The percentage is now counted across every file with the megabytes shown,

instead of jumping around as each file reported its own progress.

• A stalled download says so. If your connection blocks or silently drops the transfer, you

now get an error you can retry instead of a spinner with no end.

• Genuinely offline. The speech recognition engine itself was being downloaded from a public

CDN on every cold start, even though the same file already shipped inside Atlarix. On networks

that block that CDN, dictation simply never started and said nothing. It now loads from inside

the app.

• Dictation on the graphics card is slightly faster than before, and transcripts are

unchanged.

Already tried on-device dictation before? Your machine may be holding several hundred

megabytes of model files this release no longer uses. **Settings → AI → Voice input → Clear

cache** reclaims the space; the new, smaller model downloads next time you dictate.

The cloud transcription engines (OpenAI, Groq, Gemini) use your own API key and were never

affected.

*August 2026*

Every release now submits to the Microsoft Store automatically — no manual upload. WSL workspaces on Windows get kernel-level Landlock confinement out of the box (no need to install bwrap in the distro). The Windows sandbox also fixes two path assumptions: toolchain caches outside %USERPROFILE% are now writable, and macOS-only cache dirs are no longer created on other platforms.

• Microsoft Store submission automated — every tagged release submits to the Partner Center Submission API. Certification typically completes in 1–3 business days.
• Add/Remove Programs icon — the Squirrel installer now shows the Atlarix icon instead of the default.
• WSL Landlock confinement — the bundled Linux sandbox helper ships to Windows builds and is preferred over bwrap for WSL workspaces.
• Windows sandbox path fixes — toolchain caches (npm, pnpm, yarn, Go, Deno) outside %USERPROFILE% are now writable under Low integrity. ~/Library/Caches is no longer created on non-macOS. LocalLow is resolved via the Windows API instead of guessed.
• Microsoft Store available as a download option on the website.

*August 2026*

If you use Atlarix on Windows, this is the release to install. Agent commands that touched

git, bash, or most tools under C:\Program Files were failing outright. The sandbox that keeps

commands from writing outside your workspace was built on a Windows mechanism that blocks

*reading* by default — the opposite of what was needed — so bash.exe came back with "Access is

denied" and git could not start at all. It has been rebuilt on a different Windows mechanism that

allows reading and running programs while still confining writes to your workspace.

• Sandboxed commands now run in the same shell as everything else. The sandbox used to force

cmd.exe while the rest of the app used Git bash, so ordinary commands failed with confusing

syntax errors.

• If the mechanism cannot start on your machine, commands run unconfined with a warning

rather than failing.

• Projects kept inside WSL (\\wsl$\…) now run their commands inside the distro, where the

paths and tools actually live.

• Worth knowing: confining writes this way marks your workspace folder in a way that

persists, which means other low-integrity programs running as you — notably sandboxed browser

tabs — could write there too.

Linux: one command, truncate, could still empty a file outside your workspace. Write

confinement now covers it.

Windows and Linux icons are finally Atlarix's own. The Windows installer and app icon still

carried the upstream project's logo, and the Linux packages shipped a generic one. Every icon now

comes from a single source image.

Attachments accept any text file. File types are recognised from their contents rather than a

fixed list of extensions, so .mjs, .vue, .svelte, .scss, .ps1, .tf, .kt, .zig —

and files with no extension at all, like Dockerfile, Makefile and LICENSE — attach and

preview normally. Anything outside a 39-entry list used to be treated as an unreadable blob.

• `.ts` files on Mac are fixed. macOS registers .ts as MPEG video, so attaching a TypeScript

file recorded it as a video.

• SVG now arrives as source, which models can actually read, instead of as an image they

cannot decode.

• A JPEG saved as photo.png is recognised for what it really is.

Files you `@` mention appear as attachments. Picking a file with @ showed a chip while you

were typing, then sent as plain text with nothing to preview. It is now a chip you can click to

read the file.

Microsoft Store packaging. Atlarix now builds as an MSIX package for submission to the

Microsoft Store. A Store install keeps the workspaces, chats and credentials you already have,

and is updated by the Store rather than the in-app updater.

Known limitation — on-device voice input. The free on-device transcription engine does not

work on all graphics hardware; on some GPUs it cannot run the compressed model at all. That is

not new, but it used to appear as a mic icon that spun forever. It now fails visibly, stops

re-downloading around 500 MB on every retry, and can be retried without restarting the app.

Settings → AI → Voice input has a Clear cache action for the downloaded weights. The

bring-your-own-key engines (OpenAI, Groq, Gemini) are unaffected, and a proper fix is tracked.

Other fixes: the "install Git" message no longer shows Windows and Linux users a macOS-only

command, and Git bash is now found wherever git is installed (scoop, chocolatey, portable) rather

than only under Program Files.

*August 2026*

Signing out no longer signs you out. That is not a typo. Two things were reported — "I

didn't sign out, so why does the app log me out when I close it?" and "I keep losing all my API

keys" — and they turned out to be one mistake in two places. When your Mac's keychain was

briefly unavailable at startup, Atlarix read that as "there is nothing saved here" and then

wrote that emptiness over the real thing. Your session and your API keys were not lost; they

were overwritten with nothing. Atlarix now tells "unavailable" apart from "empty", retries, and

refuses to write an empty file over one that has contents. Signing out clears your

credentials and nothing else — your workspaces, sessions and history stay put, and if you do

want them gone there is now a checkbox that says so.

Free plan workspace limits no longer delete anything. The limit used to be enforced after

the fact, by removing workspaces you already had. It is enforced when you create one now, so

nothing you have made can disappear behind your back.

The assistant can create and manage your automations. Ask for "run the test suite every

weekday at 9" and it schedules it. Every automation — whether you or the assistant creates it —

must say whether the assistant is notified when it runs, so an unattended job cannot quietly

spend on your behalf without you having decided that. Automations the assistant creates now

appear in the panel immediately.

Automations got a proper time picker and pipelines. Set a schedule by scrolling hours,

minutes and AM/PM instead of writing cron by hand — and cron is still there underneath if you

want it, so anything you could express before you still can. The GitHub trigger is now a

pipeline trigger where you type the host yourself, so it is not limited to one service by

design.

The assistant knows where your workspace is, and what your plan allows. It was never told

the actual path of the folder you have open, so it occasionally guessed one and lost a turn

finding out it was wrong. It also learned your MCP and automation limits only by hitting them,

which made a plan limit look like a broken workspace. Both are stated plainly now — and on Pro

it no longer suggests upgrading to a tier that does not exist.

Start a session by pasting, and it gets a name. A session whose first message was nothing

but pasted text stayed called "Untitled" — not for a turn, but for as long as it ran. It is

named from the conversation now, and if the first attempt has nothing to work with it tries

again on the next reply rather than giving up for good.

The assistant no longer has its own terminal tabs. Its commands and their output already

appear in the chat, so the tabs were a second copy of the same thing. Removing them fixed three

real problems, including one worth stating plainly: when the assistant asked for output it had

already produced, it was shown a list of open terminals — and that list included yours. Your

terminal tabs are untouched, and now genuinely private.

Smaller things. @ leads with your actual files instead of dotted config folders. A cloud

model whose key went missing is labelled with its real provider — it used to read "(local)"

while Atlarix Core quietly answered every message.

---

*August 2026*

`@`-mention now finds every file in your project. It used to run one of three different

search engines depending on what happened to be installed on your machine — which meant

`@` behaved differently for different people: with one tool present you were offered files

your project ignores, without it you were not. Worse, its limit applied to the *project* rather

than to your search, so in a repository of about 5,500 files roughly 1,500 of them could not be

@-mentioned however you spelled the name.

There is one engine now — the same fast search Atlarix already used for grep — and your

.gitignore decides what is hidden rather than a hand-maintained list of folder names. Each

keystroke runs a live search instead of reading a list that could be up to five minutes old, so

"did you mean this path?" answers correctly right after a rename. The menu no longer reshuffles

while you type.

Permission handling was measured before anything was removed. Four suspicions about

duplicated security layers were tested and all four were wrong — the layers answer genuinely

different questions. What the check did find was a real gap: **ask rules in

.atlarix/permissions.json never actually asked.** They were read, matched, and written to a

log — so anyone who configured one believed they had an approval gate they did not have. The

key is gone and now warns if you have one. Two output-truncation bugs were also fixed along the

way, including one that cut text mid-character on emoji and non-Latin scripts.

Workspace hooks are removed. .atlarix/hooks/ and its settings panel are gone. Between

inline approvals, committable permission rules and per-workspace settings, a second

shell-executing policy mechanism was not carrying its weight.

Accessibility statement. Published at [atlarix.dev/accessibility](https://www.atlarix.dev/accessibility),

covering both the website and the desktop app. It claims no conformance level, because

nothing has been formally audited, and it names what does not work today — including that the

terminal and side-by-side diffs are hard to convey non-visually, which is unsolved.

---

*August 2026*

The context meter tells the truth now. The breakdown under the token counter was reading

only the visible text of a conversation and ignoring everything the assistant had actually

read — file contents, search results, command output — which in a coding session is most of

what it is holding. It now shows seven honest lines (conversation, files read, search results,

other tool output, skills and instructions, system prompt, current input), they **add up to

the total, and they climb live while the assistant works** instead of appearing only once

it stops. Reverting a turn takes the numbers back down with it.

Skills stop shouting and start waiting to be asked. Every installed behaviour used to be

pasted into the assistant's context on every single message, whether or not it had anything to

do with what you asked — and if you had a lot of them, or a long one, they were quietly cut

off mid-sentence. Now the assistant sees a one-line summary of each and reads the full thing

when it's actually relevant. Nothing is truncated, and nothing falls off the end: install

twenty and all twenty are visible to it.

Work across more than one repository. If the assistant needs to touch a folder outside the

project you opened — a sibling repo, a shared library — it asks once for that folder,

remembers it, and gets on with it. Before, it would show you the change, you'd approve it, and

the write would then fail with a message telling you to reopen the folder as a project. You

can grant a folder ahead of time or revoke one at any moment under **Settings → Workflow →

Folders outside this workspace**. Every individual change still asks for approval — a grant

only removes the outer wall. Reading a neighbouring project now just works, too.

A plan when the work deserves one. Ask for something broad with no structure in mind and

Build now writes a short plan first, then works through it in order, so you can steer before

it has built the wrong thing. A one-line fix still just gets fixed.

Security fixes. Several things could change on your machine with less of a say than you

should have had:

• The assistant could write its own hook file — a file Atlarix runs as a shell command

before and after every action — with no approval card shown at all. It now asks, like

anything else.

• Nothing outside your project folder is ever silently approved any more, whatever it is

named. That also fixes the assistant's own project notes, which were being written without

showing you.

• A rule like "always allow .ts files" applied only inside your project, as it always

should have — it was matching files anywhere on disk by extension alone.

• A change to a file outside your project could quietly spoil Revert for the files inside

it that were changed at the same time.

• A directory change the assistant wrote into a command no longer grants it anything.

Commands that reach outside your project stay sandboxed instead of running unrestricted.

Fixes you should notice. Live streaming status, in-progress tool details, inline write

previews, plan file updates and several other pieces of the interface had stopped updating

entirely — eleven of them, all silently. Debug mode is called Debug everywhere, including

in the assistant's own understanding of it. And a long task that fills its context now

summarises itself and keeps going, rather than stopping.

---

You can now clone a repository from any git host — GitHub, GitLab, Bitbucket, or your company's

own server — over HTTPS or with an SSH URL. An SSH URL is used exactly as you typed it, so your own

keys sign you in; previously it was quietly converted to HTTPS, which threw those keys away.

Choosing where to save a project is easier and no longer depends on the system folder picker: you

can type the path as well as browse for it, and Atlarix checks it while you type. On some Linux

desktops the picker doesn't open at all, and that used to leave you with a Clone button that

wouldn't light up and no way to find out why.

When a clone can't proceed, the button now tells you what's missing — a URL, or a folder to save

into. And when a clone fails, you get the real reason: the repository is private, the URL is wrong,

you're offline, or Git isn't installed. Every one of those used to arrive as the same sentence.

Long clones also show honest progress instead of sitting at 15% until they finish.

• A private or mistyped repository is named as such, with advice that matches the host you're

cloning from — not a prompt to connect GitHub when you're cloning from somewhere else.

• A hiccup reaching GitHub is no longer reported as "repository not found." Being offline or

behind a proxy sent you hunting for a typo that wasn't there.

• Cloning from a non-GitHub host no longer marks the project as a GitHub project, which

previously meant a later push could be aimed at the wrong place entirely.

• The branch Atlarix records is the branch you cloned. It always assumed main.

Atlarix now reads its model catalogue live instead of shipping a fixed list, so new providers and

models show up without waiting for an app update — 175 providers and counting. Your own API keys

reach more of them, and keys are found under any of a provider's documented environment variables

rather than one hardcoded name.

Two things that used to interrupt you don't any more. "Always allow" now works on every file —

certain paths like GitHub workflows, package.json and lockfiles were hardcoded to ask again on

every single edit with no way to opt out, so editing a workflow meant approving it forever. You

still see the diff before every write, and a "never allow" choice is still respected; you can just

make the decision once now. And pressing Stop actually stops — it could previously restart the

assistant, which then had no memory of being stopped.

When the assistant plans work, a step only *you* can do — rotate a key, test on hardware, click

something in a dashboard — can now be marked as yours with a reason, and it stops re-attempting it.

Steps it's genuinely stuck on are reported honestly instead of being quietly ticked off.

Project instructions and the assistant's own notes are no longer pasted into every single message.

That also fixes a real bug: instructions longer than a few thousand characters had their tail

silently dropped, so rules near the end of your .atlarix/atlarix.md were never actually applied.

Notes now live per-project outside your repository, so they're never committed and never shared

between projects.

• Undo is available on a turn you stopped. The file changes were always saved, but the Revert

button was hidden unless the turn finished normally — so the turn you most wanted to undo was the

one you couldn't.

• Atlarix Core credits are no longer given away by a misconfigured model. A Core model whose

price entry resolved to zero billed nothing at all, silently, on every call.

• Your account appears as soon as the window does, instead of after a sign-in refresh that can

spend seconds retrying.

• Sub-agent results read like the rest of chat — properly formatted, and folded away once the

task finishes so they don't sit between you and the answer.

• "Reset everything" leaves the app usable. It closed the database but kept running, so

everything afterwards failed until you restarted.

• Long instruction files, code blocks containing JSON, and inline citation links all render

correctly again.

This one came out of a single bad edit. Atlarix tolerates small differences when it looks for the

code you asked it to change — the wrong indentation, a stray quote — so that a model that is

almost right still gets the job done. But that tolerance only ever applied to *finding* the code,

not to writing the replacement, so on one occasion it wrote the model's stray backslashes straight

into a Go file and broke it. Worse, it then told the assistant the mismatch had been about

indentation, which sent it looking in the wrong place for a long time.

Both halves are fixed: the same tolerance now applies to what gets written, and when Atlarix

accepts an imperfect match it says exactly which kind of difference it forgave. An edit that it had

to guess at now always shows you the diff first, even if you have approvals turned off.

Looking for more of that shape turned up a few smaller ones. A background job that finished after

its own reminder timer would still nag the assistant to go check on it. A project folder you

deleted and cloned again stayed greyed out as "Folder not found" until you restarted the app. A

command that failed was announced as "successfully executed" right next to its error code. And a

chat you started by pasting something, without typing, never got a name.

The assistant's instructions were reorganised too. Guidance about a tool now travels with that

tool instead of sitting in a preamble it reads on every single message, which leaves noticeably

more room for your actual work — and it made a weaker model measurably more accurate in testing.

• The docs are now separate pages instead of one long one. There is a short index, and each

topic — getting started, work modes, how Atlarix reads your codebase, running commands,

sub-agents, models, the browser, the command-line build — is its own page you can read on its

own.

• The plan card shows the plan. Marking a step done used to display a bare "Done"; now you see

the status, how many steps are finished, and the checklist itself.

• Edits no longer put stray characters into your files. When Atlarix forgives a small

difference while locating code, it now applies the same correction to what it writes.

• When it forgives a difference, it tells you which one — indentation, a quoting difference, a

matched block — rather than always blaming indentation.

• An edit Atlarix had to guess at always shows you the diff, regardless of your approval

settings. A guess is exactly the case worth a second look.

• Chats started by pasting get a name. Previously, if your first message was only a pasted

file or snippet with nothing typed, the chat stayed "Untitled" for good.

• A project folder that comes back works again. Delete a repo and clone it to the same place

and Atlarix picks it up — no restart.

• A finished background job stops asking to be checked on.
• A failed command is reported as failed, not "successfully executed".
• Plan updates no longer leak raw data into the chat. Occasional fragments of machine output

could appear next to a plan card.

This release covers four versions of work (14.18 through 14.21) that hadn't shipped yet.

The headline is how delegated work now behaves. When the agent hands a coding job to a

sub-agent, that sub-agent no longer writes anything: its edits come back as a proposal per

file, and the main agent reads each diff and decides. Accepting writes the sub-agent's exact

work — nothing is retyped along the way — and a file that isn't already on your allow-list

still asks you, exactly as it would for any other edit.

Sub-agents are also visible now. A long one moves to the background on its own instead of

holding the turn, and the running-tasks chip lists them alongside background commands, so you

can watch progress or stop one without waiting.

• Delegated code changes are reviewed before they land. Previously a sub-agent worked in a

hidden copy of your project and handed back one big diff, truncated if it was long. Now each

file arrives separately with its own diff. If two sub-agents changed different parts of the

same file, both can be accepted; if they changed the *same* lines, that is flagged as a

conflict rather than silently resolved.

• If a file changes while a proposal is waiting, the change is re-fitted onto your newer

version when it still fits, and refused with an explanation when it doesn't — it will not

overwrite work you did in the meantime.

• Sub-agents appear in the running-tasks chip, with elapsed time, live progress you can

expand, and a stop button. They were previously invisible there and could only be stopped

from inside the agent's own turn.

• A sub-agent taking more than 30 seconds moves to the background automatically, so the

turn keeps going. A foreground sub-agent previously had no time limit at all, which is why

one occasionally looked stuck. One that goes quiet for a long time now nudges the agent

instead of stalling silently.

• Sub-agents can be referred to by name, not just an id — the same as background jobs.
• Delegated work in Plan mode can now fan out across subsystems and web research instead

of being limited to a single helper.

• Each window is its own workspace. Windows are named after the project they have open,

and a window's browser tabs, terminal tabs, and plan cards belong to that window alone —

they no longer leak into another one.

• The agent can send a command to a named terminal tab and read one back, instead of

opening a new tab each time.

• Writer sub-agents no longer need a git repository. In a project that isn't tracked by

git they previously ran read-only without saying so clearly. They also see files git

ignores, which they could not before.

• Fewer, clearer tools. terminal_read/terminal_list folded back into background jobs;

listing and stopping sub-agents moved to its own tool.

• Automations lost the "worktree writes" mode. Existing automations set to it become

read-only runs. Nothing else about automations changes.

• The disk space a removed feature left behind is reclaimed on first launch.

• Background work no longer dies with "Core has an issue." Resuming a turn after a

background task finished could fail outright on some models.

• Older messages are no longer silently deleted from a long conversation. The turn history

was being trimmed without telling you or the model; now it isn't trimmed, and the model is

told its actual context size rather than guessing.

• A long session no longer breaks partway through because the sign-in token used for

Atlarix Core had gone stale mid-stream.

• A 1,000-line edit no longer freezes the app for several seconds. The diff is now

computed before it reaches the screen, and a very large one starts collapsed with a summary.

• The token counter survives a restart and updates when you switch work mode.
• A plan step that fails to tick is now recorded, and a plan can no longer be marked

complete when it never started — the cause of a spurious "18/18".

• Renaming a session by editing your first message now works; a name you typed yourself is

still never overwritten.

• A fast model now streams its answer instead of just appearing. Some providers reply

quickly enough that the whole answer landed in one step — the text never streamed, and the

view jumped to the bottom in a single jolt. Replies are now revealed at a steady rate, so

reading one feels the same whichever model you picked. Models that were already comfortable

to read are untouched: the limit only applies to output arriving faster than that, so

nothing has been slowed down to achieve it. If you have reduced motion enabled, text

appears immediately as before.

• A custom credit top-up below the $10 minimum is now refused as you enter it, with the

reason, instead of being added to your running total and then rejected at checkout.

• The app is much quieter on the network while idle. A one-time account setup step was

being re-requested on every session check, once for each part of the app that asks who you

are — dozens of identical requests for something that can only happen once. Requests that

overlap are now answered together. Nothing about your balance or plan is cached, so a

top-up still shows up straight away.

Core used to reach every managed model through OpenRouter. It now calls the provider APIs

directly, which is why the model list is shorter and sharper: GLM 5.2 and **DeepSeek V4

Pro**, both with a one-million-token context. One prepaid balance still covers all of them —

you are billed what a reply actually costs on the model you used, so switching mid-conversation

is fine.

• Your answer no longer ends up inside the "Thoughts" card. Every model that wraps its

reasoning in <think> tags — DeepSeek included — was having the visible reply captured as

part of its thinking, so reasoning and answer appeared mixed together. A reply that *opened*

with reasoning could vanish entirely. Four separate places normalised those tags the same

wrong way; they now share one implementation, so they cannot drift apart again.

• A stray `</think>` no longer appears in the middle of a reply. Some models send the

closing tag on its own; it had nothing to match against and was rendered as text.

• Atlarix Core now knows how big its models really are. Core was reading its context window

from the wrong catalog and falling back to 128K — so a million-token model was being compacted

at roughly an eighth of its real capacity, throwing away context that never needed to go.

DeepSeek on Core now resolves its true ~1M window.

• Thinking settings reach the model in the shape it actually accepts. Reasoning options were

picked per *provider*, so every model from a given provider got the same request — which is why

MiniMax M3's thinking behaved oddly while its sibling looked fine. Each model's own declared

capability is now used, and a model is never sent an effort level it does not support.

• Models that reject a `temperature` setting are no longer sent one (Kimi K3 among them).
• Citations link to pages, not to raw source files. Web search kept surfacing code files,

which crowded out the articles and docs that answered the question. The citation preview also

showed a blank panel; it now shows the search excerpt, with buttons to open the page in

Atlarix's own browser tab or externally.

• Discord profile pictures load, and the account badge says Discord instead of GitHub.

• The token meter names what background work spent your tokens. Sub-agents and context

compaction were shown as a single figure labelled "Sub-agents", so work the app did on your

behalf looked like work you had asked for. Each source is now listed separately with its call

count.

• The agent knows where it is on a page. Reading a page now reports scroll position, so it

scrolls to find content that only loads further down instead of concluding it is absent.

• The Core model list follows the catalog. Atlarix can run two, three or four Core models and

the picker shows exactly what is configured — no placeholder rows for slots that are empty.

• Core web search now uses the built-in search tool and the in-app browser. OpenRouter's

server-side search is not available to Core any more, and none of the direct providers offers an

equivalent over a plain chat endpoint. A dedicated search integration is planned.

• A Core model that is temporarily unavailable says so plainly and points you at the other

Core models or your own API key, rather than implying all of Core is down.

• You stay signed in across restarts. v14.16.0 moved the startup session restore to *after* the window appears — the change that stopped the app hanging for minutes on a bad network. The renderer therefore starts signed-out and is corrected once the session lands, but the handler receiving that correction could only ever *update* an existing signed-in state, never establish one. So the correction was dropped and you were asked to sign in again, with a perfectly valid session sitting in the app the whole time. It now re-reads the session from the main process rather than trusting the notification, which carries plan details but no identity. A second fault with the same effect is fixed too: the user's identity was only recorded *after* their plan had been looked up, so a failed lookup — exactly what happens offline — discarded the session.
• A provider's models appear the moment you save its API key. Model lists are cached for five minutes and were only refreshed by a few specific events; saving a key wasn't one of them. Add a key and the model picker kept showing the list from before it existed, so a provider you'd just set up looked missing — and deleting a key left its models behind. Fixed at the single point every provider form writes through, so it holds for every provider and any added later. No keys were ever lost — only the display was stale.
• Onboarding text no longer refers to Blueprint and Code-to-Canvas, both removed some releases ago.

• Sign in with Discord, alongside Google and GitHub. If an account doesn't share a verified email address, sign-in now stops with an explanation instead of creating a half-account that can't be plan-checked or billed.
• Settings → Community — join the Discord, review Atlarix on PeerPush, and a one-time "where did you hear about Atlarix?" question. The download of an installer carries no trace of the post, video or person that sent you here, so it's the one thing analytics genuinely cannot answer. Asked at most once per account, skippable, and always available in Settings if you'd rather answer later. It respects the analytics opt-out.

• The browser agent grew the ergonomics it was missing — several tabs at once, find-an-element by description, and the ability to press a key, hover, or scroll. It could not previously press Enter.
• The app opens without a network, in the time it takes to draw a window.
• The models.dev catalog is now the floor under every provider, so a truncated /models response can no longer make models disappear from the picker.
• Dictation, voice settings and analytics identity corrected.

• The browser agent can keep several pages open. New browser_tabs (list/create/switch/close) exposes the tab lifecycle. Previously every navigation reused the one tab, so opening a second page destroyed the first one's state.
• `browser_find` — locate an element by describing it ("login button", "search box") instead of reading the whole page first. Ranked heuristically in the page on role, accessible name and text: no model call, so it's deterministic, free and instant.
• `browser_interact` gained `key`, `hover` and `scroll`, plus typed fill. The agent could not previously press Enter — no submitting a search box, no Escape to close a modal, no Tab between fields.
• `browser_batch` — run several predictable steps in one call (fill, fill, press Enter).

• The agent's cursor is visible while it works. A pointer now glides to each target and stays on screen between actions, with a ring on the target and a chip naming what it did.
• The Browser panel opens the way the Plan panel does. When the agent needs the browser it asks the UI to open the right panel on its Browser tab, honouring your auto-open preference.

• Browser session recordings (the frame-by-frame replay). Watching the agent live is now better served by the visible cursor and the panel following along, and the ordered text record of what it did is kept.

• Screenshots work with the Browser panel closed.
• Element refs no longer shift under the agent. Refs are now held in a WeakMap keyed on the element itself, so a ref means the same element for the life of the document.
• Reads disclose the viewport they were measured at.
• Truncated reads report the real total. "capped at 200" now says "showing 200 of 1,340".
• The app no longer hangs at launch without a network.

• No more separate Preview tab — your app just runs in the browser. Open your dev server's URL in the

built-in Browser tab and the agent drives it (or you do) to see and test your app as you build. One

surface to learn instead of two.

• Errors you can act on. The Errors tab now shows real stack traces — browser console errors,

uncaught crashes, and failed network requests — so the agent can see exactly what broke at runtime and

fix it. Click a localhost:3000 link anywhere in chat or the terminal to open it in a browser tab.

• See (and adjust) the wait. Background jobs can now show a live countdown — how long until the agent

checks back — and it clears itself when the job finishes, so timers never pile up.

• Installs just work. Tools like yarn no longer fail on first run inside the sandbox, and when a

command needs to write somewhere new, Atlarix asks once and keeps going — still sandboxed.

• Quieter and smoother. Less idle background chatter, new keyboard shortcuts, and a fix for code

blocks that could spill outside their box.

• Web search for Core models. DeepSeek, Qwen, Kimi, and MiniMax can now search the web when a

question needs current information — metered through your Core credit wallet, no setup and no API key.

• Work across repos. The agent can now read and edit files *outside* your open project — an upstream

dependency, a sibling repo — instead of being walled in. Reads just work; every outside edit still waits

for your approval with a diff.

• Steadier under pressure. A full disk no longer freezes a turn — the app degrades gracefully and

tells you instead of stalling.

• Lighter and snappier. Leaner agent prompting and a trimmed dependency tree.

• Updates now download and install. Fixed the bug where an update could get stuck on "Downloading…"

and never offer to restart — auto-update now works on macOS, Linux, and Windows.

• One-time note: if you're on an older version, you'll need to do a single manual update to this

version (download it from the site). After that, future updates install automatically.

• Atlarix Core shows its real models. The Atlarix Core provider page now lists the actual models

you're using (Kimi, Qwen, DeepSeek, MiniMax) and reads "Setup Complete" — no API key needed.

• Simpler provider setup. Cleaner wording when connecting your own providers, and a single,

straightforward model picker for local runtimes (Ollama, LM Studio).

• Snappier model list. The list of available models loads faster and no longer rebuilds itself

every time you open a screen.

• More reliable auto-updates. Fixed an issue where an update could get stuck on "Downloading"

instead of finishing and offering to restart.

• Better-looking tables and code. Replies with tables that reference code no longer break into

stray rows, and inline code snippets render cleanly — Atlarix now keeps multi-line code in proper

code blocks instead of squeezing it into a table cell.

• Tidier command and tool output. Command results, web searches, and other tool output now show

just the content — the internal safety markers Atlarix uses behind the scenes are no longer

displayed in the chat.

• Clearer wallet message. If a refund leaves your Atlarix Core balance negative, the balance now

explains why and prompts you to top up before using Core again.

• Atlarix credits you as the author, not itself. When Atlarix helps you commit, your own name and email stay on the commit and Atlarix is added underneath as a co-author (the standard Co-authored-by: line) — the industry-standard approach. (On a machine with no git identity set up at all, Atlarix still signs the commit so it doesn't fail.)
• The "add Atlarix as co-author" switch now fully works. Turning it off removes the co-author line everywhere, including commits the agent makes in the terminal — previously it could still slip in.
• Cleaner, better-formatted replies. Every model is now told your chat renders as markdown, so answers come back with proper headings, lists, tables, and code blocks.

• Real model prices in the picker. Instead of a flat "Free", each model now shows its actual cost per million tokens, pulled from a live catalog (and directly from OpenRouter for your own key). Local models stay free.
• Smarter file edits. Atlarix can now apply several edits to a file in one atomic step, and understands a "here's the new shape, keep the rest" style with // ... existing code ... markers — so edits are more reliable and refuse rather than corrupt when something doesn't line up.
• A smoother, calmer harness. Big pastes no longer freeze the app, the live token counter keeps working with the usage panel closed, sending an image to a text-only model gives a friendly "switch to a vision model" note instead of an error, and quiet long-running builds are left to finish instead of being nudged to cancel.
• Security hardening. Stronger protection for stored keys when no system keychain is available, and tighter validation on privileged internal actions.

• Simpler pricing: Free + Pro, and Atlarix Core is pay-as-you-go. No plan bundles AI anymore. Atlarix Core runs on a prepaid credit balance you top up (from $10) and spend as you go — the same on Free and Pro. Every new account gets a $1 trial credit to try it. BYOK and local models stay free on every plan. (The old Team tier is gone — its one-click connectors are now part of Pro.)
• Talk to Atlarix. New built-in voice-to-text: dictate to the chat instead of typing. It runs on-device with local Whisper by default — free and private, no key — or bring your own OpenAI, Groq, or Gemini key for cloud accuracy (that never touches your Core credits).
• Automations. Schedule the agent to run unattended — on a cron, a GitHub event, or an MCP trigger — from the Automations tab, with a feed of past runs. Two per workspace on Free, ten on Pro.
• See your live usage. A running token counter shows real provider usage as a reply streams — for the main agent and each sub-agent.
• Fewer duplicate attachments. Attachments are de-duplicated by content, so pasting or attaching the same file twice no longer sends it twice.

• Commands just run — safely. Atlarix no longer second-guesses everyday commands with rigid rules that sometimes blocked perfectly safe ones (like fetching from git or building a project). In read-only modes your files are protected by a real operating-system sandbox, so commands can look around freely but can't change your code; in Build and Debug they run normally. Genuinely risky actions (deleting, sudo, piping the web into a shell) still ask first.
• Smoother, cooler long answers. Long conversations and long streaming replies now stay light on your machine — the chat only renders what's on screen, re-parses just the part that's still being written, and cleans up old leftover index files (freeing over a gigabyte on some setups). Less heat, less lag, during big sessions.
• Resume looks right again. When a reply is interrupted and you hit Continue, it now picks up seamlessly instead of showing a stray "continue" message as if you'd typed it.
• "Jump to latest" goes where the writing is. Tapping it during a streaming reply now lands you at the live edge where new text is appearing, not partway up the message.
• Sharper, more trustworthy code changes. Under the hood, Atlarix now holds itself to stricter habits when it writes tests and fixes — proving a test actually catches the bug before trusting it, and reusing what your project already has instead of reinventing it.

• Code search is now fully self-contained. Atlarix bundles its own fast search engine, so finding files and searching your code works on every machine with nothing to install — no setup, no "command not found."

• Much lighter and cooler on big repos. Atlarix no longer keeps a background index or file watcher running — it searches your code directly with bundled ripgrep. On huge projects that means no more machine heating up, no runaway file usage, and no slowdowns in long sessions. It just stays fast and quiet.
• Connect almost any AI provider. The provider list now includes every provider the community catalog knows about — 150+ — so you can drop in a key for whichever service you use and its live models (with their real context limits) show up automatically. No app update needed when a provider adds a model.
• See what each sub-agent costs. When Atlarix delegates work to sub-agents, each one now shows its own token usage right on its card, on top of the running session total.
• Tidier AI terminal. Background commands the AI runs now clean up their own tab once they finish successfully, so the terminal stops piling up tabs — while failures and long-running servers stay put for you to check.

• Your Core key never touches the app. Atlarix Core now runs through a secure hosted gateway. The managed model key lives only on our servers — it's no longer inside the app on your machine — and your monthly usage is checked and counted server-side. Nothing about how you use Core changes; it's just safer.
• No account secrets shipped in the app. Billing and email actions (upgrading, cancelling, team invites) now happen through secure server endpoints signed in as you, so no sensitive keys are bundled into the download.
• Stronger account & team protection. Hardened the rules behind plans and teams so entitlements can't be tampered with, and tightened how subscription events are matched to your account.

• Faster, cooler on big repos. Atlarix now uses a smarter, native file watcher that ignores everything your .gitignore already ignores (node_modules, build output, caches) — so opening a huge project like VS Code no longer floods your machine with work. First searches are quicker too, and long sessions stay lighter on memory.
• Smarter command approvals. Read-only commands like ls, grep, find, cat — and pipelines of them (ls | grep) — just run, in every mode, without a prompt. Anything that could write, delete, or reach the network still asks. And once you "always allow" a tool (say npm), it now works even inside chained commands. You can see and turn off the built-in auto-run list in Settings → Terminal permissions.
• Paste works from anywhere. Pasting a long prompt now becomes a tidy attachment chip even when you copy from Notes, TextEdit, or a word processor — not just from a code editor.
• One "done" sound, not two. Finishing a task now plays a single notification instead of doubling up.
• Long chats stay snappy. Very long conversations render only the latest messages (with a "Show earlier" button), and scrolling up while a reply streams no longer fights you.
• Security hardening across command handling, links, and file access.

*July 2026*

• Attachments read whole — and survive everything. Files you attach are never silently cut

short: the assistant pages through the FULL content of big PDFs, spreadsheets, and documents

(.py, .go, and every code file now previews too). Attachments keep working after you edit a

message, stop a reply midway, or restart the app — and each conversation only sees its own

attachments.

• Vision models actually see your images. Attach a screenshot or photo and a vision-capable

model receives the real picture right in your message — no roundabout steps. Models that can't

see images now say so plainly instead of confidently describing an image they never saw.

• Edits that never corrupt indentation. The file-edit tool re-anchors changes to your file's

real indentation (tabs stay tabs) even when the model drifted — the live bug where a Go file

came back with mangled whitespace is gone, verified by the model that hit it.

• Honest context numbers everywhere. The "compress context" action now actually frees space

when the assistant asks, its banner tells the truth, and every model gets its REAL context

window from live catalogs — a 1M-token model is no longer treated as 128K, so long sessions

compact ~8× less often.

• Replies read in true order. Helper-agent cards now flow thought → action → thought like the

main chat, compaction cards sit where they happened instead of sticking to the bottom, and

editing a message keeps its attachment chips visible.

• Snappier turn starts. Drag-and-drop files no longer delay the reply (heavy parsing moved

off the send path), and repeated-history token counting is near-instant — long sessions start

responding noticeably faster.

*July 2026*

• Background work you can trust — and watch. The assistant now reliably receives results from background commands and helper agents the moment they finish (no more re-checking loops), can be woken by a watch-word in a job's output (e.g. "compiled successfully"), and you can expand any running background task in the chat to watch its live output, send it to chat, or cancel it.
• One approvals flow for risky commands. Force-pushes, rm -rf, and other dangerous commands now go through the same allow / always-allow / deny flow as everything else — clearly marked with a warning badge and never run silently. No more dead ends where the assistant couldn't proceed; "always allow" is revocable in Settings.
• Thinks as deeply as each model allows. Reasoning depth is now derived from each model's own capabilities — everyday replies think harder by default, and Deep Think pushes to the model's maximum.
• No more cut-off or repeated work. Fixed a guard that could cut off legitimate multi-step editing mid-task; a genuinely stuck assistant now gets corrective guidance first (a hard stop only as a last resort), finished work is never re-run, and plans can't hijack a session after they're presented.
• Sturdier edits and search. File edits self-heal across curly-quote/dash typography differences, and code search stays fresh with the session's own edits instead of ranking them last.
• UI fixes. Chat no longer freezes when you switch models after a rate-limit error; the sidebar "new window" button opens a fresh window with the workspace chooser; finished replies keep their step cards in place; stray tool text no longer leaks into messages.
• Credit where due. Commits the assistant makes are now consistently co-authored by atlarix-agent.

*July 2026*

• Finishes the whole job. Give Atlarix a multi-step task and it now tracks its plan as a live checklist, verifies each step before moving on, and keeps going until everything is done — instead of stopping halfway. It still pauses when it genuinely needs you (a decision or a manual test) or has background work running.
• Sees your pages more clearly and cheaply. When you ask what a page looks like, Atlarix reads it as a compact text description instead of an expensive screenshot — and it no longer cries wolf about "layout bugs" that are really just intentional background/decorative layers.
• Faster, safer edits. File edits are more robust — surgical replacements self-heal small mismatches, and garbled content is auto-repaired instead of corrupting a file.
• Instant stop. Cancelling a running task now stops immediately, including the background work that used to keep your fan spinning.
• Sharper, less noisy guidance. A broad tune-up of how the assistant is instructed — clearer tool choices, fewer contradictions — so open-weight models (DeepSeek, Qwen, Kimi, MiniMax) behave like they know your codebase.

---

*June 2026*

• Atlarix tests the app it builds — no clicking required. A new headless preview test drives your running web app (open routes, fill forms, click, assert) and won't call the work "done" while the page is throwing runtime errors or failing requests.
• Smoother streaming. The chat no longer jumps back to an earlier spot mid-response or at the end of a reply — it stays pinned where you'd expect.
• No more redoing work after a long pause. When a reasoning model thinks silently for a long time, Atlarix now resumes from where it left off instead of restarting the task.
• Cleaner long conversations. Removed a redundant rolling summary that could make the model act like it forgot earlier messages; it now relies on the full conversation.

---

*June 2026*

• The agent waits like it should. When Atlarix needs your approval for an edit or command, the turn now genuinely pauses on you — the Stop button stays, and it won't claim it's "all done" while it's actually waiting. Approve and it continues the same turn; deny and it carries on; Stop cancels cleanly.
• Start long work and keep chatting. Kick off background commands or sub-agents and the turn ends and hands control back to you — then resumes on its own when the work finishes. No more sitting on a spinner while a 10-minute job runs.
• It manages its own background work. Atlarix can list, watch the live progress of, and cancel its own running sub-agents — and finished results are delivered back to it reliably, so nothing gets dropped (a big reliability win for open-weight models).
• Schedule a re-check. For things nothing can notify it about — a deploy, a remote queue — the agent can schedule itself to wake up and check back later.
• Faster, leaner turns. A loop fix removes a wasted extra round at the end of every tool-using turn — every model spends fewer tokens and finishes sooner. Sub-agent timeouts and "looks stuck" thresholds were also loosened so slow networks and large repos aren't misread as hung.
• Fixes: the context meter now drops right after compaction (and reopened sessions stay compacted); Settings permission rules now actually apply; the "Keep / Revert files" dialog returns after a relaunch; and the agent no longer re-answers a question it already answered while waiting on background work.

---

*June 2026*

• Steadier on long tasks: a brief hiccup mid-reply now quietly retries instead of stopping the whole turn, so long runs hold together.
• "Reconnecting…" only when it's real: that message now appears only when the connection genuinely drops — slow thinking, a long command, or background helpers just read as "still working." (Works the same across every model provider.)
• Your whole chat is there: the entire conversation now loads and scrolls — no more cap on how many exchanges show, and nothing gets quietly trimmed away.
• An accurate context meter: the usage meter now shows what's actually being sent to the model, so it drops back down after the chat compacts instead of looking stuck near full.
• Cleaner streaming: replies render more smoothly as they come in — no flicker or jumping while you scroll.
• Edit & re-run can undo file changes: when you edit an earlier message and resend, Atlarix can offer to undo the file changes from the parts you replaced, so a re-run starts clean.
• Review gives you a list: Review mode stays read-only and hands you a clear list of changes to make, rather than trying to edit anything itself.
• Commands show in the Terminal: the assistant's commands now reliably appear in the right-panel Terminal tab so you can watch them run.

---

*June 2026*

• Watch it use your live app: the assistant can now open, click, and fill in your running app's preview — not just a browser tab — so it can try a feature the way you would and check that it actually works. You see it happen right in the chat.
• A replay of what it did: when the assistant works through your app, you get a scrubbable recording you can scroll back and forth through — no more jumping straight to the last frame.
• Long jobs keep running: dev servers and slow builds no longer get cut off — anything still going after a few seconds quietly moves to the background, keeps running, and the assistant picks back up automatically when it finishes. You can see and stop background jobs anytime.
• Your preview just loads: start your app and its address loads into the preview on its own — nothing to wire up.
• Everyday commands just run: routine commands (listing files, checking status, running tests, installing packages, starting a dev server) run freely, while anything that changes your code or git history waits for Build or Debug mode — and genuinely risky commands still ask first.
• Bring more of your own models: any model that supports images can now receive screenshots, not just a fixed few — plus a fix for a Grok/OpenRouter web-search error.
• Clearer tool activity and tidier help: the assistant's actions read more clearly in chat, and the in-app help pages are cleaner.