Reference

On this page

Changelog

Notable changes to Nawa, newest first, in the form of Keep a Changelog. Versions are the Windows releases; Unreleased is what the development branch has gained since the last one.

1.0.115 — 2026-11-10

• In Normal mode, agents give an update when a new part of the work starts, a result changes the plan, or verification begins. Related actions share an update, with occasional notes during long stretches. A missing note does not block an action.
• When the coder starts checking an edit silently, the chat shows which check is starting. The coder can capture a screenshot as part of a browser action or wait. Main can use the coder’s findings and reopen a frame when the evidence needs another look.
• If a verification step needs another attempt, the coder can reuse the report it already wrote.
• A coder can request outbound network access for one command, such as installing a dependency. Your permission mode governs that request. An automation stays within its saved network permissions.
• Completed command, file, and browser results carry less internal bookkeeping into the model’s context. The action history retains the full record, including diagnostics for interrupted or unfinished commands.

1.0.114 — 2026-11-09

• Nawa can watch a changing page in one browser call. It records timestamped changes and returns when the expected result appears, progress stalls, or time runs out. When a check stops early, the coder can inspect the last observed state.
• The coder can test individual parts during development, then check the requested outcome from the user's starting conditions. Requesting more browser evaluation time than allowed now returns the limit immediately and keeps the session available.
• During tool use, working drafts stay out of the chat’s progress narration.

1.0.113 — 2026-11-08

• An answer can include an ordinary link to a page whose capture was discarded. Numbered citations open the saved sources used in the answer.

1.0.112 — 2026-11-07

Changed

• Provider interruptions preserve the partial answer. If part of a tool-call batch is missing, Nawa stops before acting on the batch or marking the turn complete.
• A search result can be shared as an ordinary link. Numbered citations still refer to captured sources. Literal SVG source can be returned as text, and agents can omit a progress update or repeat the same source selection without another round.
• The coder can reuse current checks across command tools, including checks for generated build outputs. Checks from different package folders stay distinct, and changes to files invalidate the affected results.
• Screenshot previews stay with the action that produced them. Sent attachment cards follow the corners of their chat bubble.

1.0.111 — 2026-11-05

Added

• Screenshots an agent inspects appear as clickable thumbnails in the action history. Open a thumbnail to see the full image, then use the arrows or the Left and Right keys to browse the group. Arrows hide at either end. Screenshots stay with the chat after workspace cleanup and can be included in an answer on request.
• Nawa Dark Heart adds an orange accent, rounded controls and a near-black background. Choose it in Settings > General > Theme template. Sidebar icons now have distinct colors within each theme.

Changed

• After you approve a foreground command, its action row shows the step the script announces, or the program running. The elapsed time starts when execution begins and keeps updating during quiet steps.
• Main passes your original request to specialists so they receive your exact wording and constraints.
• Main and specialists receive a count when successive identical tool calls return the same observation. They can use that result to try another step or explain a blocker. Polling and intentional repeated actions remain available.
• Theme-specific pane backgrounds now follow the selected theme.

1.0.110 — 2026-11-04

Changed

• Bug reports include your graphics adapters and drivers, whether Nawa is drawn by the graphics card or in software, whether Nawa runs translated on an ARM processor, each screen's size, work area and scale, and the size and zoom of Nawa's windows, without their titles. Text after the word "Basic", such as the "Microsoft Basic Render Driver" adapter, is no longer hidden as a password unless it has a password's form.

• Nawa's record of each model request, which bug reports include, states the output limit and thinking setting the request sent, beside how many tokens the model then spent thinking.

• Web search answers start sooner: content screening reads only the part of a search the model receives, and each step of a turn reuses the provider's cache of the step before.

• Sources have short ids, so the model copies them correctly when it cites them.
• The model is told the link rule the answer check enforces: a search result it has not opened is named as unverified, without a link.
• The agent list shows which helpers each agent can start, and why an agent can't be used in this chat or automation, for example because web access is off. It also lists saved agent files that failed to load, with the file and the reason.
• Agents that an automation starts get the same tools as the automation itself. Skills and the decision model need the automation's permission for both, and an automation that doesn't run in a chat can't search one.
• When the answer check rejects one wrong source marker, the model can fix just that text instead of writing the whole answer again.
• Each page read tells the model how much text it may read at once, so a long page takes one or two reads instead of many small ones.
• When a website refuses a read, the model sees the refusal page's title and whether it was a bot check, even when the page itself is too long to show.
• Reading a long page in parts no longer repeats the page's dates, images and other details with every part. A later part names the earlier result that already shows them; on a news live blog that cuts each later part from about 7,300 tokens to about 2,900.
• When the coder clicks, types or presses a key in a page it is testing, it sees what changed: text, buttons and fields, focus, pop-up messages and new errors. A large change is saved in the workspace with a short excerpt, so the coder needs fewer extra steps just to look.
• When a file edit's old text isn't in the file, the model sees the file's closest matching lines, with their line numbers and whether they differ only in spacing, instead of being told to read the file again. When the text appears more than once, it sees the line of each match. Answer edits work the same way.
• With OpenRouter, Settings lists the companies that serve each model, with their recent uptime, speed and wait for the first word, and you can mark a company Prefer or Avoid. Nawa sends those choices with every request for that model.
• Bug reports name the OpenRouter company that answered each step and, when OpenRouter moved a step to another company, which companies it tried first and how they answered.

Fixed

• Long web pages, such as large Wikipedia articles, read in well under a second instead of timing out.
• During a model outage, each content check is no longer sent five extra times in another format.
• When a research helper starts another helper, the pages the inner helper kept reach the final answer.
• A helper that set aside a page another helper had opened no longer removes it from the other helper; each helper's pages stay until that helper sets them aside.
• An agent created, changed or deleted during a turn is listed as taking effect from the next turn, and deleting or restoring an agent removes every saved file behind it.
• Tool calls a model sends without an id each get an id of their own. Before, every round named them call_1, call_2 and so on, so a later round could point at an earlier round's saved result.
• After the coder's conversation is compacted, it keeps the current text of the files it was working on, so it reads them again less often. Before, the compacted view had room for almost none of them.
• When a model's server refuses images because the model can't take them (vLLM says "not a multimodal model"), Nawa sends the step again with a note where each image was, and stops sending images to that model on that server. Before, the turn ended with the server's error, and so did every later turn with an image. Connect in Settings checks the model again.
• File edits and find-and-replace work in files whose lines end in different ways (some Windows-style, some not), and each line keeps its own ending. Before, text that crossed a line with the less common ending could never be edited, and reading part of such a file showed every line with the more common ending.
• When Nawa's usual window size would fill the whole screen, such as on a 4K screen at 300% scale with the taskbar hidden, Nawa opens maximized. Before, it opened as an ordinary window exactly the size of the screen, which looked maximized but wasn't and kept the hidden taskbar from sliding up. Dashboard windows do the same instead of opening taller than the screen.
• When the coder updates an AGENTS.md notes file after checking its work in the browser, those checks still count. Before, the note made Nawa ask the coder to check everything in the browser again.
• Renames, formatting and fixes from a language server keep each line's own ending, and work in files whose lines end in a lone carriage return (old Mac style). Before, such a change rewrote every line of a mixed file to the more common ending, and in a carriage-return file it was refused or aimed at the wrong line.
• Writing a file tells the model only what was written. Before, rewriting a long file with few changes added a note telling the model to use file edits instead, and a rename or code fix in a long file got that note too, though the model hadn't rewritten anything.
• Finding, hovering over and renaming code work in UTF-16 files, and on the first line of a file that starts with a byte-order mark they land on the character the model read there. Before, a UTF-16 file's functions and classes weren't found and positions in it were wrong, and on that first line a position pointed one character early.
• With OpenRouter, a model's context size is the one served by the company OpenRouter sends its requests to first, the same company its output limit already came from. Before, Nawa took the largest size any company offers, so Qwen3.8 27B showed 1,024,000 tokens instead of 262,144, and long chats went much longer before compacting.
• When a provider reports partway through a reply that it is busy for a moment, such as OpenRouter's "temporarily rate-limited upstream", Nawa sends the request again, as it already did when the provider said so before replying. Before, the reply stopped with "Model request failed".
• When a provider reports an error partway through a reply, the failure notice shows what the provider said. Before, it said only to check the model's settings and try again.
• Bug reports record a model request you stopped as cancelled, and one that ran past its time limit as timed out. Before, stopping a reply partway through was recorded as a provider error, and a stop or time limit before the answer arrived was recorded only as a number.
• Code lookups say when Nawa's own reader can't read a file's type, such as Go when no language server is running. Before, such a file was reported as having no symbols or definitions. A large JSON file, such as a big package-lock.json, no longer makes symbol, definition and reference searches report a skipped file, and a search or replacement that finds nothing no longer adds a sentence restating it.
• Finding, hovering over and renaming code by its name alone, without its file, still works when another code file can't be read, such as one another program has locked or one saved in an old Windows code page, and the model is told which file couldn't be read. Before, one unreadable file made every such lookup fail, even for code defined in other files.
• When code is looked up by its name alone and several files define that name, the model is told about every one of them beside the one it was given. Before, it got the first one found and could not tell that the others existed.
• On a computer that draws its screen without a graphics card, such as Windows in a virtual machine or over Remote Desktop, and where Nawa runs translated on an ARM processor, Nawa's animations that run while it works, such as the shimmering "Working..." text, change a few times a second instead of moving smoothly, and the thinking icon changes 7.5 times a second with a faint trail. Before, they kept a processor core busy for as long as a reply took. Where a graphics card draws Nawa's window they still move smoothly, and the thinking icon uses about half the processor time it did before.
• The coder's browser pauses the page it is testing 5 seconds after each of its steps and resumes it at the next one, so what a step started, such as a page change or a late error, still happens. Before, an animated page such as a game kept drawing for as long as the browser stayed open, about a whole processor core the entire time. The page isn't told it was paused, so a game that pauses itself when hidden is still playing where the coder left it.
• Code searches across the whole project, for functions, for where one is defined and for where it is used, say how many files of each type they didn't read. Before, in a Go project with no language server running, they found nothing and still reported a full search, so the model couldn't tell that the Go files were never read.

1.0.109 — 2026-10-31

Changed

• Settings → Privacy now holds Help improve Nawa and Location. Permission controls remain in General, and existing choices are preserved.

• Both Windows editions include the same fixes below. The Microsoft Store edition continues to disable Tailscale, remote access and website updates; the website edition retains its direct update channel.

• With Anthropic, Nawa reads each model's context window and output limit from Anthropic's model record, so long coding work uses the model's full window and compacts far less often.

• Coding work keeps Anthropic screenshots in place until a request nears Anthropic's image limit, and changed AGENTS.md files reach the model as additions after the latest results. Earlier messages stay unchanged, so the provider's prompt cache keeps the conversation.
• Tool results sent to the model leave out values the tool contract or the same result already states, such as the sandbox's fixed settings and derived browser error counts. Stored results keep everything.
• Before each step, Nawa estimates the request size from the provider's own counts and asks for an exact count only near a limit.
• Workspace checks reuse the fingerprint of files that have not changed, checkpoint commits write only the repository, and saved previews copy files in parallel.

• Bug reports include your model connections: each one's provider, server address and model, whether a key is saved for it, and a saved key's length and public prefix. Keys, setup names and other account settings stay out.

• A model's context size comes from the model itself: Settings shows it beside each model with where it came from, and Compact at (%) sits beside it for Main and Coder. Composer context tokens and the separate Context compaction card are gone, and nobody can set the size.

• A server that reports no context size is assumed to have 256,000 tokens. When it refuses a longer request and states its limit, Nawa uses that limit from then on and compacts and resends the request instead of stopping.
• Context sizes from a provider's model list are used as stated, no longer cut to 272,000.

Fixed

• Main and the coder receive screenshots consistently when their model supports images, including images returned by tools.

• Quiet model responses are no longer mistaken for stalled work just because no text is visible yet. Connection and response failures identify the stage that failed, while Stop remains available.

• A workspace app's services get ports outside the range Windows also gives outgoing connections, so a busy machine no longer takes a service's port before it starts.

• Running the same command twice is recognized as the same result even when the finished process tree's shutdown snapshot differs.
• Connect asks OpenRouter to confirm the key, and shows its refusal instead of a working connection. OpenRouter shares its model list without a key, so a key from another provider used to look connected while every message failed.
• With no model saved, the model menu asks you to choose one instead of picking the first model the provider lists.
• Vite builds and tests work inside the sandbox. When the workspace folder or a folder above it, such as the user profile or Temp, blocks sandboxed commands from opening it, Nawa adds one read-only entry to that folder alone.
• Anthropic accounts that bind replayed reasoning to unchanged history no longer fail after Nawa compacts a conversation; only the affected reasoning is dropped.
• A read-only coder check that ends with its report is reported as finished instead of as unfinished work.
• A coder can edit AGENTS.md without reading it again when the file's current content already reached it.

1.0.108 — 2026-10-29

See What's new in 1.0.108 for the changes since 1.0.100, refreshed screenshots and the edition comparison.

Changed

• Website and Microsoft Store installers are built and tested together from the same source revision. The Store edition retains its local-only remote-access restrictions and separate installer updates.
• Release publication verifies both editions and refuses to replace an existing version's installer with different files.

Fixed

• Workspace apps start correctly on Windows systems whose connection table omits listening sockets. Nawa verifies the owning process through the native listener table.

1.0.107 — 2026-10-28

Changed

• The Microsoft Store edition supports local use only and no longer offers Tailscale remote access. Existing website profiles cannot enable remote access in this edition. Website installations keep their remote-access features.
• The Store edition requires a newer Store-edition installer for updates; it does not install updates from the website feed.
• Desktop Control now explains that Cua's helper is a normal application, not a device driver or Windows service.

1.0.106 — 2026-10-28

Fixed

• Stopping a running command responds promptly on Windows. Nawa signals the command’s process owner directly, verifies descendant cleanup, and keeps other chats responsive during cancellation.

1.0.105 — 2026-10-28

Changed

• Model-server connection retries use the connection notice, showing the current attempt with the same text shimmer as actions. The notice clears when the server connects or the turn stops.
• Web search (DDGS) searches in the background without an API key or an open browser. Automatic uses it when no search API is configured, and saved DuckDuckGo selections migrate automatically.

Fixed

• A failed model-capability check preserves the selected reasoning level and Thinking status instead of silently switching to Working.
• Realtime and image-only models no longer appear as chat choices.

1.0.104 — 2026-10-27

Changed

• New installations start with Nawa Dark. Existing installations keep their saved theme.
• PowerPoint, PDF, Word and Skill Creator use the supplied icons, displayed at the same size as Computer Use.

1.0.103 — 2026-10-27

Changed

• Each chat keeps its own model routing, reasoning selection, web selection, spending observations and provider errors. Supported model pricing supplies clearly labeled cost estimates when the provider does not report a cost.
• Saved reasoning levels are reconciled with the selected provider's reported capabilities, so unsupported choices do not remain selected.
• Main hands implementation planning to the coder with the complete request and test requirements, reducing repeated planning. Tool calls can carry public progress narration.
• Learned memories are saved immediately with Undo beneath the answer. Chat notes live in the chat's AGENTS.md, and the handbook explains both kinds of memory.

Fixed

• Tool requests printed as text recover through supported native tool calls. The coder receives explicit completion requirements and feedback when finish_coding is missing, and repeated missing-tool replies stop with a clear result.
• PowerPoint work preserves supplied slide designs and reports preview failures instead of hiding them.
• Compaction and conversation indexing handle empty briefings and cut-off output more reliably. Memory search matches whole words and finds text inside Chinese, Japanese and Thai content.
• Removing chats and projects releases their notes and previews. Memory cards and sources leave the answer's copy controls accessible.

1.0.101 — 2026-10-20

Fixed

• Windows Setup now explains that installation can take several minutes, including the final stage, and keeps that guidance visible while it works. Installer and uninstaller artwork preserves the Nawa logo's original proportions.

1.0.100 — 2026-10-19

Changed

• A gear at the bottom of the left pane opens Settings, and the bug icon for reporting a problem sits beside it instead of at the top right of the chat. Both stay in place while the chat list scrolls. Edit → Settings…, Ctrl+, and Help → Report a Bug… still work.

1.0.99 — 2026-10-18

Fixed

• A prompt you steer into a reply that is still running stays in view, marked Waiting until Nawa picks it up, also after you switch to another chat and come back. Before, it left the queue and showed nowhere until Nawa picked it up or Stop returned it to the queue. Coming back to a running chat also keeps following its newest output if you were following it when you left, and keeps your place if you had scrolled up to read.

1.0.98 — 2026-10-18

Added

• Gmail and Google Calendar connect with your Google account directly. In Settings → Connectors each has its own Connect button, and each asks Google only for its own read-only permission: reading your mail, or seeing the events on calendars you own. Before Google's sign-in page opens, Nawa says what it will read and that the text goes to the model provider you chose. After you allow access, the page offers Return to Nawa, which brings you back to Settings → Connectors. If the permission box on Google's page was left unticked, Nawa does not connect and says so. Disconnect also withdraws Nawa's access at Google when no other connection uses the same account. Google is still reviewing Nawa, so its sign-in page warns that the app is unverified; choose Advanced, then Go to Nawa, to continue.
• Image Generation has themed cards for Replicate, Black Forest Labs, Ideogram, Stability AI and Recraft, alongside the existing six providers. Native APIs support generation and reference edits, queued-result polling, connection checks, and Recraft SVG output. Existing Fleet settings and selection are preserved.
• Main and Coder each remember their own context compaction percentage for every model and server, with 80% as the default, even when they use the same connection. Existing shared percentages are preserved as separate values for both roles. Switching models restores each role's saved percentage; changing or clearing one role leaves the other unchanged and applies to new turns without altering active work.

Changed

• The message box's button for connected services shows a plug, sits after web search, and shows its card while any connected service is on for the chat; with every service off it is just the icon. The connector directory (Settings → Connectors → Add connection → Browse connectors) lays its cards in two columns when the window has room, and closes when you click outside it.

1.0.97 — 2026-10-16

Added

• Windows application, installer, uninstaller, and native helpers now carry verified publisher signatures and timestamps. Release builds scan Nawa binaries with SSL.com before signing.

Changed

• Nawa checks again how a model's server takes a demand for a tool call: whether the model can be made to call a tool, and whether it takes a tool asked for by name. It checks on the next request that needs it, a day after it last found out or after you press Connect in Settings. In Nawa 1.0.96 and earlier, a server's refusal was kept until the server reported other settings, even after Connect, so a server you had set up differently was still asked the old way. An error 500 to a forced call also counted as such a refusal; now Nawa asks that request again the accepted way and checks again the next time it needs to force a call. The troubleshooting page said Nawa remembers these refusals; it now says for how long.

1.0.96 — 2026-10-13

Changed

• Nawa now uses each provider's prompt caching, so the instructions, tools and conversation that every round of a turn sends again are read back from the provider's cache at a fraction of the input price. Anthropic requests mark what to cache. Tools and instructions are kept for an hour and the conversation for five minutes. OpenAI and OpenRouter requests carry the chat's id so they reach the same cache, and so do xAI requests. Providers that cache on their own, such as Gemini, DeepSeek, Groq and local servers, get no new fields. DeepSeek's cache hits now count in the token totals.
• Requests now only grow at their end between rounds, so providers can reuse almost all of each earlier request. Research progress is added as it happens instead of being rewritten each round. Each turn's time, sources and workspace details sit next to your message instead of inside the instructions. A compaction summary sits beside the instructions. Earlier tool results and file contents are shortened only when the conversation is near its limit. A two-turn news search on Claude cost about half as much as before.

Fixed

• A chat turn you stop, or one stopped for inactivity, shows as stopped when it happens, with the files it changed, even while its checkpoint waits for other Nawa work. A message sent right after it starts once that checkpoint is committed instead of failing, and an agent the stop interrupted shows as stopped when it finishes.

1.0.95 — 2026-10-11

Fixed

• Long-running chats build verified, reusable briefings from completed actions during compaction, preserving current work, steering, unresolved failures and recent native reasoning. Exact earlier records remain available for retrieval.
• Large lists of changed files stay responsive when expanded, and new files show their added and deleted line counts instead of dashes.
• Composer token and spending controls stay within the available width on narrow layouts.

1.0.94 — 2026-10-10

Added

• The composer shows provider-reported spending after Sum, including supported API-key budgets, account balances and chat costs. Hover identifies the scope, currency, observation time and missing cost coverage.
• LLM providers have individual JSON manifests for their setup metadata, API routes, authentication and supported spending observations. Settings and the engine use the same validated catalogue.

Changed

• Settings connection buttons are labeled Connect, including model, image, decision and search providers. Model-list hints and the provider guides use the same wording.

• LLM provider cards consistently label their roles Main and Coder, including hosted providers.

• LLM settings place Connect beside the API key, with Model and Temperature on the next row, for Main and dedicated Coding connections. The separate capability research button has been removed.

Fixed

• The context gauge keeps approximate request counts visible between provider responses and identifies estimates explicitly, instead of reverting to an unexplained dash.
• Composer token and spending pills wrap within the available space on narrow screens.
• Saved API keys stay with their connections when settings cards reorder or are saved repeatedly. Background and explicit account saves stay ordered, and stale references to deleted or replaced keys are rejected instead of clearing or substituting credentials.
• Unresolved model-provider rejections display their reason and any retry interval, including temporary in-flight spending limits. The notice survives reopening the chat and does not erase earlier completed actions.
• Model lists stay empty before a successful connection test, clear when credentials or URLs change, and reject obsolete test results. Connection tests save pending credential edits before contacting the provider, so an old key cannot make an invalid new key appear to work.

1.0.93 — 2026-10-10

Fixed

• Windows updates preserve the existing bundled runtime after requesting administrator access for all-users installations. Updates of Nawa installed in Program Files no longer attempt to move protected files before elevation, and cancelling elevation leaves both runtime copies intact.

1.0.92 — 2026-10-10

Fixed

• Switching model setups keeps each provider's model catalogue and selection with its own connection. Capability checks allow reasoning models enough output to finish their probes.
• OpenAI uses its Responses API for reasoning and tool calls, preserves private continuation data, and accepts conversations restored from earlier versions.
• Tool definitions preserve their optional arguments and constraints across native APIs and gateways, preventing rejected schemas and empty responses through OpenRouter.
• Provider requests preserve API path prefixes and query parameters, including Google Gemini, Groq and custom gateways.
• Gateway reasoning controls use the model's declared effort levels and whether its reasoning can be turned off.

1.0.91 — 2026-10-09

Fixed

• Full installations show measured unpacking progress and an animated indicator with elapsed time through file copying and final setup. The progress window stays responsive while the installer works, then returns to the completion page. Updates use the same progress display and show activity during stages without a measured percentage.
• Setup uses crisp Nawa artwork, sharper text on high-resolution displays, and a cleaner progress window.
• Windows packages use compression supported by the installer, so all bundled Python launcher files unpack correctly.

1.0.90 — 2026-10-09

Added

• A guided tour on new installations: it opens LLM / Image gen to connect a model, then highlights the workspace controls where you use them. Skip it at any point, or replay it from Settings → General → Getting started → Take a tour.
• Choosing Bypass permissions first shows a warning; Cancel keeps the previous mode, and Don't show this warning again remembers the choice on this device.
• The reasoning button beside the chat input opens a menu of the modes the model supports, with Main chat and Coder tabs, instead of switching thinking on and off.
• Coder reasoning has separate Inherit from Main chat and Custom reasoning controls. New installations inherit; Coder choices saved before this release are kept as Custom. Choosing a Coder level in the composer sets Custom reasoning while preserving its model connection. Settings, saved setups and outgoing requests use the same choice.
• A new PowerPoint skill (nawa-powerpoint) designs whole decks as editable PowerPoint files: nine styles, your brand's colours, fonts and logo or your own .potx template, 20 slide types including native charts, tables, timelines and icons, a storyline with takeaway titles, style choices and an outline you can steer, slide previews, and checks for text that does not fit, contrast and overlaps. Arabic decks are laid out right to left.
• A new Word skill (nawa-word) writes reports, proposals, memos, manuals and letters as editable Word files with real Word styles: seven styles, your brand or your own .dotx template, a designed cover, a table of contents, numbered headings, styled tables, native charts, callouts, key-figure rows, captions, headers and footers with page numbers, page previews and checks. It also converts Markdown, and Arabic documents are laid out right to left.
• A new PDF skill (nawa-pdf) designs PDFs from Markdown, HTML or ready-made templates - reports with a cover, contents, charts, tables and callouts, invoices and quotations with checked arithmetic, letters, certificates, CVs, one-pagers and fillable forms - in seven themes or your brand, with page previews and checks for text that runs off the page or hides under other content. It also works on any PDF: merge, split, reorder and rotate pages, extract tables to Excel, fill and flatten forms, watermark, stamp and Bates-number, redact with proof that the text is gone, compare versions, compress, password-protect and edit bookmarks. Arabic documents are laid out right to left.

Changed

• Settings no longer has a Background helper role. Chat titles, context notes and the screening of web and tool content are written by the Main model, with its reasoning turned off (or at its lowest level for a model that cannot turn it off). A different helper model chosen before is no longer used, and its saved settings are removed.
• An update adds new built-in skills to an existing installation once (a skill you remove afterwards stays removed, and a skill of your own with the same name is kept), and removes a built-in skill Nawa no longer ships when you have not changed it.
• Errors and connection notices appear in a slim strip above the composer, with the full diagnostic one click away. A model connection failure also offers Retry and Open settings.
• Cloud setups show the Coder reasoning choice, and the Coding role's linked option reads Use Main chat's model.

Fixed

• Sending from higher up in a chat leaves the view where you were reading; Nawa works on the prompt below. From the end of the chat, the prompt still moves to the top.
• A sent prompt no longer drops down the transcript before its answer arrives: not when the previous answer is still appearing, not when you scroll down, and not when the turn's own content changes. Scrolling up keeps exactly the place you scroll to.
• Starting a run while a notice, queued prompts or changed files show above the composer no longer shifts the transcript.

• With reasoning off, a turn shows Working... instead of Thinking..., and its finished steps read Worked for instead of Thought and worked for. If the model streams reasoning anyway, the indicator says Thinking....

• Reasoning chosen beside the chat input is saved with the active setup, so switching setups and back no longer restores an earlier choice.

• Collapsed queued prompts keep their Send arrows, and a single queued prompt has no reorder handle.
• The Files drawer includes hidden workspace folders such as .git and .nawa.
• The live elapsed-time pill is hidden while the drawer fills the chat area and stays within the available chat lane.
• Arabic and Hebrew text in PDFs reads in the right order when Nawa reads a PDF, whether attached, in the workspace or opened from the web: lines are no longer reversed, Arabic letters are no longer returned in their joined display forms, and numbers, Latin words, percentages and table cells inside right-to-left lines keep their order. Text in other languages reads exactly as before.

Removed

• The built-in docx, pptx and pdf skills, replaced by the Word, PowerPoint and PDF skills above.

1.0.89 — 2026-10-07

Added

• An optional Share basic usage statistics switch in General settings, off by default. Participating desktop installations send their version and a random daily ID while interacting with Nawa. Chats, prompts, files, accounts and server settings are excluded; turning the switch off stops future reporting.
• A private website admin analytics dashboard with Cloudflare R2 download trends, participating daily/current activity, version adoption, delivery health and aggregate CSV/JSON exports. Daily identifiers are stored separately from permanent totals and excluded from application backups.

1.0.88 — 2026-10-07

Fixed

• Uninstalling Nawa shows progress and a completion screen, including after an update. Automatic updates retain their existing progress window, and explicit silent uninstall commands remain silent.

1.0.87 — 2026-10-07

Fixed

• Public installations start without a preconfigured personal model server or model aliases. Server examples use loopback addresses, and the sidebar starts at its standard width.
• New vLLM connections accept your own server URL with or without an API key and preserve the key when saved. Existing account settings remain intact.

1.0.86 — 2026-10-07

Fixed

• Generated documents and other files use source links, footnotes, or references that work in their format. Nawa's internal citation markers are reserved for chat, where they render as numbered citations.
• Capability discovery now includes the browser and workspace tools available through delegated agents. Nawa can discover those tools when asked to inspect a page or take a screenshot, including when web research is disabled.

1.0.85 — 2026-10-07

Added

• Web search can use Brave, DuckDuckGo without a key, Google or Bing through SerpApi, Tavily, Exa, or your SearXNG server. Settings has provider cards, encrypted keys, connection tests and an optional fallback order. Native search filters are preserved, and incompatible fallbacks are reported. All model-visible search fields use the shared incoming-content screening before optional Jev ranking, including deeply nested provider metadata.

• Unsupported file formats can request a model-created drawer preview. Verified applications are cached against the full original file hash and built separately from its contents.

• Video and audio file pills now open a playable preview in the Files drawer, with native playback controls, seeking and fullscreen for videos. Streams support byte ranges, playback stops when the view closes, and files that cannot be decoded show an error.

• Chat can add and test MCP connections, review and install local or catalogue plugins, and start OAuth sign-in through the same setup services as Settings. Changes refresh the interface immediately, persist across restarts, and make new native tools discoverable in the same turn. Permission modes, local plugin installation authority, encrypted credential storage, package revisions and truthful connection status remain enforced.

Changed

• Coding agents receive explicit completion requirements before submitting their work. Project discovery exposes recorded check results and their freshness, while native command results can be associated with discovered checks through the existing completion contract.
• Long transcripts render a window of messages and load activity details on demand. Captured research sources support adaptive reading with exact continuation and recovery.
• Progress and final reports distinguish observations from hypotheses and describe what the recorded checks actually covered.

Fixed

• Completed context compaction now closes its progress indicator when a rebuilt request is accepted. Estimated input-token counts no longer reduce the model's advertised context capacity.
• Plugin discovery respects disabled tool calling. Repeated verification observations retain incoming-content screening, including after compaction.
• The Thinking indicator stays hidden while any tool is still running, including concurrent tool calls inside nested agent work.
• Citation favicons remain readable across themes, and shared outline icons use consistent strokes.

1.0.84 — 2026-10-05

Changed

• Documentation has a visible Home link, linked breadcrumbs and section overviews, collapsible navigation with the current section open, a compact mobile On this page menu, related guides and useful footer links. Search, Previous/Next and Back to top remain available in website and bundled Help.

• Documentation uses the colored Nawa favicon throughout website and bundled Help.

Fixed

• Text right-click menus use the native Windows menu again, including spelling suggestions, dictionary additions and standard editing commands. Selecting text offers a separate themed toolbar for asking Nawa, explaining a passage, formatting input or editing a table, without duplicating native clipboard actions. Specialized file and artifact menus remain available.

1.0.83 — 2026-10-05

Changed

• Queued prompts appear oldest first in a compact pair of peeking titles above the input. Unfolding shows separate themed cards with full-width text and actions underneath. Editing replaces a whole card with a text input and Save/Cancel buttons; Enter adds a line, and both the edit and main input drafts survive a reload.
• Connector settings show added accounts, applications and services together under Tool connections, with their logos and per-connection permissions. Unused Google and Microsoft account providers are no longer prelisted; new connections come from the connector library or a custom setup.
• Inline skill and agent mentions use distinct theme colors and their available icons without a surrounding pill. The desktop skill appears as Computer use.
• File revision guidance asks Nawa to preserve the original and deliver a new file unless the user explicitly requests an update in place.

Added

• Skill creation now supports optional repeatable evaluations against ordinary execution, with isolated trial chats and a results page showing outcome checks, activation, time, tool calls, and token usage.

Security

• Packaged releases disable Electron's Node entry point and Node inspector at the executable level. Public builds also leave developer tools and reload shortcuts out of the application menu; private development builds keep them.

• A browser on the same computer can no longer pair as a remote device. The coder's browser follows the network permission granted to its workspace commands, including WebSocket, service-worker and WebRTC traffic.

• An installed Nawa no longer starts with a debugging switch. Before, any program on your computer could add --remote-debugging-port to Nawa's shortcut and, the next time you opened Nawa, control it: read your chats, use your connected accounts and approve its own permission prompts. Now Nawa refuses to start with that switch, --remote-debugging-pipe or Node's --inspect switches, before it opens a window, and writes one line naming the switch to firstrun.log. The executable also disables Node's inspector before application code runs.

Fixed

• Prompt cards now visibly fold and unfold, new queued prompts slide and fade into place, and accepted prompts animate into the conversation. New prompts beyond the two peeking titles visibly enter the folded stack. Merge joins a card with the one above, animates upward and offers an icon to split it again. Dragging keeps the original grab point instead of jumping around the insertion line. Queue refreshes no longer cancel these transitions. Reduced-motion settings keep the same behavior without animation.

• Skill saves validate every bundled path before changing the package, preserve existing assets during updates, and roll back failed writes. Concurrent saves require explicit overwrite permission. New evaluation references are added to untouched stock creators while preserving customized or deleted skills.

• Nawa includes a verified Windows esbuild compiler that handles permission-denied parent directories correctly without weakening sandbox permissions. The composer build uses it, and compatible project SDKs can select its app-owned path explicitly. Existing project dependencies and caller overrides remain unchanged.

• Long Windows working-folder paths launch through an existing short name only when it identifies the same physical folder. Parent-folder lookups and permissions are preserved; when no suitable short name exists, the original Windows failure remains visible. Helper and workload launch folders are recorded separately.
• A workspace opened through a Windows junction uses its physical folder identity for commands, Git, outputs and permissions. Paths through the selected alias still work, while a link that escapes or is retargeted outside the granted folder is refused.
• Sandboxed Node commands load Nawa's path support from an execution-owned, immutable helper, so coding also starts from an installed application in a Windows profile folder. Caller preloads, workspace paths and permissions are preserved. The helper is removed with its process tree, and sandbox protocol records preserve Unicode paths.
• A sandbox runner's input or output pipe failure now keeps the original transport error, any output and observed exit facts, and explicitly marks the execution incomplete. Cleanup is bounded and stops only that runner; a late close cannot finish the command twice. Successful repeated results still compare alike when their runner process IDs differ.
• The elapsed animation and changed-files pill use their measured heights to keep their spacing and the jump-to-bottom button clear at different sizes.
• A queued instruction now continues the same parked build exactly once. The composer restores its Stop button immediately while the instruction is being queued, and a manual Stop remains in effect until you explicitly continue the work. Queued attachments follow the ordinary message path instead of waiting indefinitely.
• Background workspace copies preserve dependency folders and links within the copied tree. Clean verification uses Windows junctions for installed dependencies in root and nested projects, and reports a failed dependency link instead of silently omitting it.
• Diagnostics wait for a language server's registered diagnostic pull when required, including Pyright. A failed or malformed pull cannot reuse an older successful result as a complete new check; failures identify the affected server and files.
• Kept drafts report their file count and size and are superseded along their app's lineage. Attachment seeding preserves whole validated workspace paths, including Unicode names and filenames containing consecutive dots.
• Browser diagnostics, workspace summaries, attachment previews and skill descriptions use token budgets and state which content was omitted. Complete source records remain available through their evidence references.
• Shared line icons use 1.6px strokes, including scaled and exported SVGs. Action cards use 18px artwork, MCP and Web use the supplied icons, and Open in drawer uses the drawer artwork. Removed icon code stays out of the app and Help.

• Passing tests remove their temporary folders and browser profiles without following dependency links. Failed tests keep their evidence; cleanup retries transient Windows failures and reports the exact path that could not be removed.

• A message you send to a background build you stopped now continues it. Before, the build stayed paused and your message waited, although the line under it said "Ask me to continue whenever you like." Now the build starts again with your message as its instruction, and the reply follows it.

• A background build that Nawa's watchdog stops for going quiet, for example because the code reviewer helping it stopped answering, now stops as if you had stopped it, and your next message continues it. Before, it failed and couldn't be continued, and asking the assistant to continue it found nothing to resume. Now the line under its message says why, for example "I stopped the build after 5 min without activity during the code-reviewer dispatch.", and the build's record keeps what the watchdog saw.
• A step still running when you stopped a reply or a build, or when the watchdog stopped it, is no longer shown in red. Its card shows it as stopped and keeps what the step reported.
• When a build stops, the line under its message now says why at once, and only under the newest message about it. Before, it appeared only after you reopened the chat, and under every message you had sent the build.
• Long titles of presented images and pages, custom agent descriptions, and long names and types of attached files and e-mail attachments are now kept whole instead of cut off, and a new chat's title is made from more of a long first message.
• When a provider answers with a failure, every line Nawa shows now states it the same way: who answered, the status once, then the message the answer gives or what the answer was. This covers the failure card, Test connection for the image server and the decision models, the connectors panel and the bug report dialog. A page is described by its size and type, and an empty answer is said to be empty. The card now reads, for example, "The model provider answered HTTP 400 Bad Request: …" instead of repeating "Model request failed". Before, a decision refusal without a message read "HTTP 401 (HTTP 401)", the bug report dialog said only "<host> answered HTTP 502." or "[object Object]", the connectors panel showed nothing for a server's refusal, and the image server's test said only "answered HTTP 200" for an answer without a model list.
• A decision model's Test connection now says what was wrong when the answer is not a decision, or shows the model read only part of the input. Before, it said only "The connection test failed."
• When a provider's answer breaks off partway, the line now says so, with what the connection reported. This covers the card, Test connection, Settings' model list, the connectors panel and the bug report dialog. Before, Settings reported the connection ready with 0 models, and the connectors panel said only "terminated". The bug report dialog adds "The report may have arrived." when the website had accepted the report. An MCP server whose sign-in refusal breaks off now shows Needs authentication instead of Failed to connect.
• A test that reaches nothing now names the request, such as "Model-list request could not reach the provider: …" or "Decision request could not reach the provider: …". Before, Laya's test said only "Nothing answered at …".
• Settings' note for a provider that refuses automatic tool choice shows the provider's whole answer up to about 1,024 tokens, and a longer answer by its summary and size. Before, an 11 KB answer filled the status.
• When the assistant's coder stops before finishing a new version of an app, its unfinished files are now kept. The assistant can read them, show them to you, or hand them to the next agent until the chat is deleted, or until a later version of the same app is finished. Before, they were deleted as soon as the coder stopped.
• The assistant and the agents working for it can now use the files of an app it delivered, through the link it gave you. They can view its images, read its documents, show them in the chat, use an image as input for an edit, hand the files to another agent or a background build, and open them in their own browser. Before, every tool refused that link, even though you could open it. Links to another chat's apps are still refused, and nothing can change an app's delivered files.
• Screenshots and errors from outside frames are now screened too. A screenshot Nawa kept of an outside page used to be read back as a project file. An error that an outside frame or script raised on one of your project's pages was judged by the page, so it reached the assistant unscreened. And a kept file remembered only the first outside site it held. Now screenshots record the outside sites they show, every error is judged by the frame or script that produced it, and each kept file lists every outside site it holds.
• A request Nawa's browser blocked is now listed once in a page's errors, as blocked. Before, it also appeared as a failed request.
• When a code language server can't be told that files changed, the coder can now restart it, and only that server's files wait for it. Before, nothing could restart such a server until the next coding session, and the coder could still count the files it had checked as verified by naming them. Now those files are listed as unconfirmed until the coder restarts the server, which then reads every file again; files other language servers checked still count.
• With Nawa open in two windows, a change one window saves to a chat, such as its name, pin, draft, review comment or permission mode, is no longer undone when the other window saves the same chat. Before, the other window's save wrote back its older copy of the chat and erased the change.
• Clicking a chat whose messages failed to load now loads it again. Before, clicking the open chat did nothing; you had to open another chat and come back, or send a message.
• Removing a file from the message box while another is still loading now removes that file. Before, it removed the file after it, or nothing when it was the last one.
• When the assistant's answer links pages it only saw in search results and never opened, Nawa now points this out to it once, with the exact links, before you see the answer. The assistant can open the pages, drop the links, or say they weren't opened. Before, such links appeared as if they were the answer's sources, as plain links instead of numbered source pills, even though no page had been read.
• When you attach a PDF, the message box and your sent message now show only the PDF. Before, Nawa added a picture of each chart, figure or scanned page it found, up to eight per PDF, beside your file as if you had attached them. They stayed in the chat after it was reopened and were sent to the assistant with every message, so a scanned PDF could make a message too large to send. The assistant can still look at those pages whenever it needs to, and it is now also told which pages with pictures Nawa didn't draw, so it can look at those too.
• Chats from before this version no longer show the pictures Nawa drew of an attached PDF's pages. A message saved then showed each picture beside the PDF, also after a restart, in the turn list, and in a draft or queued prompt saved then, and every later message in that chat sent them to the assistant again. The pictures stay in the chat's folder, where the assistant can still look at them.
• Nawa no longer shows or offers you its own files. The Files drawer leaves out its folders, .nawa and uploads/.page-previews, and the files offered as downloads leave out the coder's screenshots and notes and the pictures of a document's pages. Before, a coder's result could list them as files it made or as files not delivered, and the assistant's list of a chat's downloads could include page pictures, or come back empty once a long build had left 40 screenshots. Nothing is deleted: the assistant still reaches these files, and links to them still open. A coder's result also no longer lists files inside its folder's .git, or calls its search incomplete because of .git.
• A chat whose messages fail to load now says so in red, with the reason, instead of looking empty. A chat's messages load when you open it, or when Nawa starts for the chat that is open. When that load failed, the chat showed an empty conversation, and a message sent in it was answered without the earlier conversation coming back into view. Now the chat shows "Conversation not loaded" with what Nawa's server answered, such as "Nawa's server answered HTTP 503: …", or that it did not answer. Opening the chat again from another chat, or sending a message in it, loads it again, and its messages replace the notice.
• When the coder building a new app hands work to a reviewer or another agent, that agent now works in the app's draft and sees exactly what the coder built. Before, it worked in the chat's folder: it couldn't see the coder's files, could read chat files the coder can't, and when revising a saved app its browser showed the chat's app data instead of the saved app's.
• A file the coder makes while building a new app, such as a report, now downloads from the copy saved with the app. Before, its link pointed into the chat's folder and opened nothing, or a different file with the same name. A file from an app that was never finished was offered too; such files are now listed as not delivered.
• Outside content that Nawa keeps as files in a project's .nawa folder is now screened when it is read back. This covers the output of a command that declared its web sources, a plugin's images and files, an image server's answer, and the errors an outside page logged in the browser. Before, reading those files back gave them to the assistant as your project's own content, so instructions hidden in them weren't screened, and an outside page's archived error log was saved as Nawa's own record. Now Nawa records where each file came from when it writes it, and every read of it is screened like the original result.
• When a code language server can't be told that files changed, its results now say so. This applies to a server you added yourself, or a TypeScript server whose settings you changed. Before, after strict was switched off in tsconfig.json, such a server kept reporting the old errors as complete. Now the result is marked incomplete and names the changed files the server wasn't told about.
• The help now says that Bypass permissions runs connected-service tools set to Needs approval without asking, and never runs a tool set to Blocked. Before, it said Bypass still asked before those tools.
• A dashboard now shows "Saving layout..." until your latest layout change is saved. Before, when you resized a tile and then moved one while the first save was still running, the first save's finish hid the status while the move was still unsaved.
• The assistant now always receives Nawa's citation rules: cite the pages it actually read, and treat search results as leads to open rather than as sources. Before, the rules came only with an optional finishing step, so an assistant that wrote its answer straight after a web search never saw them and could answer from search snippets alone, with no citations.
• A folder linked into your project or chat folder with a junction is now treated as a link everywhere, whoever made it. Before, a junction one of the assistant's commands made outside node_modules, for example with mklink /J, left every later command's check of the folder incomplete, so the coder could not finish and a background build could not start. The change review listed the linked folder's files as your changes, and checkpoints saved them in your project's history, including files from outside the project. Undoing a change could delete a file inside a linked folder. Now Nawa records where each link points without looking inside it: the review names links instead of listing their files, checkpoints leave them out, a copy is refused and names the link, and an undo that would change a file through a link is not started.
• A background build's coder can now hand work to the code reviewer or another agent with the tools a chat's coder gives them: the browser, code intelligence, tests, image viewing and the change list. Before, such an agent could only list, read and search files, so it could not run the build's app or its tests. It works in the build's folder.
• A coder building a new app can now point another agent at a folder of its draft, such as notes. Before, Nawa looked in the chat's folder and refused with "Approved read path does not exist", or treated the draft's own files as outside the workspace.
• An agent can no longer give an agent it dispatches outside folders or network it doesn't have itself without your permission mode deciding. Before, a coder could do this without anything asking, even in Manual. A dispatched agent now gets its dispatcher's network by default.
• When the assistant imports files from a folder on your computer, it now learns why a file couldn't be read, as it does for an attached file: a PDF that can't be opened, an empty text file, or what the file reader reported. Before, it learned only that reading failed, errors were cut to 200 characters, and one file that couldn't be copied ended the whole import.
• A document with a very long outline, such as a Word file with thousands of headings, no longer fills every request in its chat. Nawa sent all 3,000 headings (about 61,000 tokens) each time; it now sends the start of the outline and keeps the whole of it in the chat's folder for the assistant to read.
• When a chat's folder or its memory can't be opened, the assistant now learns the full error and its cause, such as the database error behind it. Before, it received a shortened message.
• A background build now records every coding session in its progress note, however long the note grows, and a request longer than 20,000 characters reaches its coder whole.
• When a server's answer breaks off partway, Nawa now keeps what arrived. The decision model's Test connection for Laya said "Nothing answered at …" even when the server had answered, including a 503 that means no worker is loaded. It now states the connection error and the answer's status, such as "UND_ERR_SOCKET: terminated: other side closed (HTTP 200)", and says "No Laya worker is loaded" for a 503. When the assistant presents a page, picture or video whose answer breaks off, it now learns the answer's status, type and the part that arrived, where it read only "terminated". Web search, MCP servers, token counting, image references and error pages keep the same facts. A bug report whose receipt breaks off is no longer recorded as refused by the website.
• When Nawa can't save a step's result with the chat, for example while its database is locked, it keeps a copy in the project folder for the assistant to read. Reading that copy now gets the same Activity classifier review for instructions aimed at the assistant as the original result. Before, a copied web page, plugin result or command output that read an outside source reached the assistant unreviewed. A coder building an application in its own draft folder can now read these copies of its own steps, including the one it continues from after its conversation is shortened. Before, reading one failed with "No file at …". The chat's folder still keeps them after the draft is closed.
• When a research step can't save a page it chose to keep, the assistant now learns what the chat's storage reported, such as the database's own error, instead of "The source snapshot was not saved to durable conversation storage."
• A background build's coder can now hand work to another agent, such as the code reviewer, naming files in the build's own folder. Before, Nawa treated a build's paths as if the build had no folder: a hand-off that named a path such as notes was refused with "External filesystem paths must be absolute: notes", and one that named a folder in the build the agent may write to was refused for lacking expected outputs. A build's folder is now its workspace for every step it takes, as the chat's folder is for a chat turn, and a folder outside it, the chat's own included, still counts as outside.
• A file tab whose file Nawa cannot display, such as a damaged image, now reports that once. Before, when Nawa was busy, showing the tab could report the failure twice, and each later refresh the tab made on its own tried to display the file again and reported it again; for a table it built the preview again each time. Now the failure stands until you open the file again, choose Refresh, or the file changes.
• A chat you delete now stays deleted. Before, deleting a chat while the assistant was still answering, or just after a reply, could store it again a moment later with its last messages, because the page saved the chat while it was being deleted. After a restart the deleted chat was back in the sidebar. Its folder could come back too, and a file attached to it afterwards was copied into a new folder for it. Now nothing saved, sent or attached after a deletion brings back the chat or its folder.
• Quitting Nawa no longer leaves a puppeteer_dev_chrome_profile-… folder (about 2.7 MB) in your Windows temporary folder. After you export a message as a PDF, or as a Word document with a diagram, Nawa keeps a hidden browser open, and the coder's browser may be open too. When Nawa quit it stopped them but left their profile folders behind; it now removes them. Folders left by earlier versions stay until you delete them.
• A long conversation or background build no longer fails as too large for the model when Nawa's conversation database can't keep its older steps. To make room, Nawa saves those steps and puts a reference in their place. When the database refused the save, Nawa wrote a complete copy into the project folder but then ignored it, and the request failed with "The complete request cannot fit safely in the selected model's context window." A background build not tied to a chat keeps everything in its own folder, so it failed this way whenever it grew long. Now Nawa continues from the copy, and the assistant reads the older steps there.
• When Nawa can't save a step's result to its database, the record now states what happened: the missing piece, such as the chat for a build not tied to one, or the database's own error, and why no folder copy was written. Before, it said "Durable conversation storage was not configured for this tool operation." and kept only the error's message.
• When a model's server refuses the way Nawa demands its final answer (an error 500, or a refusal of the tool choice), the reply now continues and the provider's answer is remembered. Before, the reply failed, and so did every later reply that needed the same demand. If the server ignores that demand, Nawa no longer repeats it until the reply times out. On a vLLM server that starts serving another model under the same name, Nawa checks again how to ask it.
• Research & verify capabilities in Settings now reports what each reasoning-level test returned: why it stopped, the usage the provider stated, and the size of its reasoning and answer in tokens. Before, it judged the model from the number of characters of reasoning it got back, so a model whose provider counts reasoning without returning its text, such as one stating 384 and 1,536 reasoning tokens, was judged to have no reasoning control.
• When checking outside content for instructions, fetching a page to present, or reading an automation's watched file fails, the record now keeps the whole error with its cause. Before, these records kept a few of its fields.
• When a TypeScript project's tsconfig.json, jsconfig.json or a JSON file it imports changes, the coder's next diagnostics and lookups follow it. Before, for about three seconds they still came from the old settings, marked complete: turning strict off still showed TS7006, and a new path alias left imports unresolved.
• While a background command runs, the log tail the assistant reads now holds the same output as the command's output. Before, it could lag behind or run ahead of it, and a character not yet fully received showed as �.
• When the connection to the model drops mid-answer, the turn's issues, its trace and an agent's result now name the connection error, such as UND_ERR_SOCKET. Before, they said provider stream error, incomplete stream, or a failed agent dispatch.
• Help now says the built-in browser runs outside the command sandbox, as an ordinary process with your account's rights and Chromium's own sandbox on. Before, it said the browser ran under nawa-exec.exe.
• An app's preview can no longer show another program in its place. To run an app the assistant built, Nawa picks a free port, frees it, and tells the app's server to use it. Before, a program that took that port first answered Nawa's check that the app had started. The preview, the assistant's browser checks of the app and a saved app's thumbnail then showed that program's pages as your app. The same happened when Nawa reused a running app whose server had stopped listening. Now Nawa uses the port only after the system's list of listening ports shows the app's own processes there. When another program holds it, the launch fails naming that program, as in "Port 65146 of workspace service frontend has a listener outside the service: process 44520 (node.exe) on 127.0.0.1", and Reload application starts the app on a new port. Starting an app whose server runs under another process, such as npm run dev, takes about a second longer.
• Projects that install packages with pnpm now run in Nawa on Windows. Nawa ran Node with options that stop it following pnpm's links, so the code failed with "Cannot find module". That happened whether the packages were installed in your terminal or by the assistant. Now Node follows the links as it does outside Nawa.
• When the assistant installs packages with pnpm, pnpm's store now goes in Nawa's own .nawa folder. Before, it went into your project, where reviewing changes compared each store file (500 files, 149 s in one case), checkpoints saved them, and a background build would have copied them into the project.
• Deleting a chat in which the assistant installed pnpm packages now removes its folder. Before, the deletion took about two minutes and left the folder.
• When the model provider refuses a message, the failure card now says what it answered, e.g. "Model request failed with HTTP 400 Bad Request: Invalid 'tools[0].function.name'…". A busy or unavailable provider (429, 5xx) shows its answer under LLM unavailable. Before, the card said only "The selected model couldn't complete the request. Check its settings and try again.", and the assistant's next turn read that same sentence. It now reads the provider's answer.
• The image server's Test connection no longer says "Connected" when a web page answers at its address; it says "The image server answered HTTP 200". When nothing answers, it states what the connection reported instead of "fetch failed". An answer that breaks off keeps its status, here and when the assistant generates an image, where it read "terminated". A card with no Server URL says "Enter a server URL first." instead of IMAGE_SERVER_NOT_CONFIGURED.
• The decision model's Test connection quotes a plain-text refusal, e.g. "Missing API key (HTTP 401)", where it said "HTTP 401 (HTTP 401)". It states an unreachable Jev endpoint's cause instead of "fetch failed".
• A background build that runs long enough to need shortening now continues. Before, the build failed with "The complete request cannot fit safely in the selected model's context window." at the point where its conversation needed shortening, because Nawa had nowhere to save the build's work, and every step's result was marked as at risk of being lost. A build's results are now kept with its chat, as a chat turn's are. Its coder can now also search the chat's conversation and your saved memories, use the decision model you set up, and follow the requirements you set in the chat's memory, as the coder in a chat turn can.
• A streaming reply no longer stops scrolling with its text after a scroll report that moved nothing. Nawa follows a reply to its end until you scroll away, and it took any scroll it had not made itself as yours, judged by how far the end then was. Chrome can report the transcript's position again without moving it, as after part of the transcript folds away; once the reply had grown below the view, such a report could turn following off, so the rest was written out of sight. A reader who had scrolled up a little could likewise be taken back to the end. Now only a scroll that moves the transcript counts as yours.
• Opening a chat whose messages had not loaded yet — after a start, any chat but the open one — no longer leaves "Loading conversation…" over another chat. Going back to a chat already shown, or pressing New chat, before those messages arrived showed "Loading conversation…", and it stayed until something redrew the conversation. When the messages arrived, Nawa also loaded the chat again: confirming a rename unchanged did not lock the title, as it does in a loaded chat, and a message stored meanwhile that Nawa had already shown, such as an automation's report, vanished for up to 15 seconds. Now the chat loads once, only a chat still loading says so, and newer messages stay.
• With a Google or Microsoft account connected, Nawa no longer asks to use a connected service before steps that don't use one, and Plan mode works again. Before, once an account was connected, a chat in Manual, Accept edits or Auto showed a card such as "Use the connected-service tool read_file" before almost every step: reading or listing files, loading a plugin's tools, handing work to the coder, and each of the coder's own steps, down to its final report. A plugin's tool asked twice. In Plan mode all of those steps were refused, so the assistant could not even read your workspace to make its plan. Now only searching and reading your mail and listing your calendar follow the account's tool settings in Settings → Connectors, and a plugin's tool asks once, by its own setting. Plan mode still refuses both, and every other step follows the permission mode as it does with no account connected.
• When the assistant reads pages of a scanned PDF, Nawa now draws and transcribes each page it reads. Before, only pages already pictured when the file was attached could be transcribed: at most eight per document, picked by how much each page looked like a picture. In a 12-page scan, reading pages 9 to 12 returned no transcription, and neither did a page with only a little text.
• When Nawa reads an attached file but has to skip part of it, the assistant now learns what was skipped and why, such as a PDF page that couldn't be drawn or an e-mail attachment that couldn't be decoded. Such an attachment used to be listed as 0 bytes and saved as an empty file. When a file, or the picture of one of its pages, can't be saved in the chat's folder, the assistant now learns why; before, only Nawa's log said so.
• The assistant's list of attached files now says whether each file was registered for reading, and how many of an e-mail's attachments were left out. A file whose inspection fails with a very large error no longer makes the message too large to send.
• One provider entry in Nawa's settings file whose address is not a full http(s):// address no longer breaks every model. Before, every capability check in Settings said "The provider endpoint must use HTTP or HTTPS." and every message failed before reaching the model. Now only a connection that uses that address fails.
• When a model's capability check fails with a long answer, such as a gateway's error page, the assistant and its agents no longer receive the whole page with every request. Nawa keeps it in the chat, where the assistant can read it, and its status names it. The image notice and the Activity classifier's failures now also mention a failed check of the coding or classifier model.
• In Settings, choosing a model whose provider refuses automatic tool choice now says why its status is red, as Test connection does. A failed token count is no longer shown again for up to ten minutes: within five seconds a check says it is repeating the earlier failure and when it happened, and after that it asks again. A vLLM server whose model settings cannot be read is asked once per five seconds, not before every count.
• When a vLLM server's settings declare a token-counting address that contains a name and password, Nawa no longer repeats them. Nawa never uses such an address, but it kept the address as written, so the name and password appeared in the model information that Settings receives, in the saved model record, in the details of a failed request that the assistant reads in its next turn, and in Nawa's log. Each copy now has [REDACTED] in their place. Bug reports already hid a name and password in a web address; they now also hide a single token written before the @, as in https://token@host.

1.0.82 — 2026-10-02

Added

• The token counts under the message box now say how much of a chat's input its model's provider served from its prompt cache, when the provider states it. Every request sends the conversation again, and a provider that caches the conversation's beginning reads that part without computing it again, so the input count alone overstates the work. Pointing at the counts now shows, for example, "Cached input: 84k, as stated by the provider for 31 of 40 request(s).", or that no request's provider stated a cached count. OpenAI and OpenRouter state it, Anthropic states its cache reads, and a vLLM server states it when it is started with --enable-prompt-tokens-details. Nawa's daily token record keeps the same count for each model and role, with the number of requests that stated one.

Changed

• The assistant and the coder are now told how the tool calls in one of their responses run: in order, one at a time when any of them acts, such as writing a file, running a command, or using a browser or an app. Every response is a whole model request that sends the conversation again, and their instructions said to wait for each result before an action that depended on it. So opening an app, clicking a button and reading the page's errors took three requests, and so did every step on a desktop app; in measured chats, half of the coder's input went to requests made right after a single browser step. Now they are told to send actions they have already decided together and to wait only for a result that decides the next call. Nawa already ran such calls in order, each with its own result.
• Screening outside content for instructions aimed at the assistant now reads each distinct piece of text once per message. Before the assistant reads a web page, a search result, a plugin's result or other outside content, Nawa has the Activity classifier model review it piece by piece. Before, a piece that repeated was reviewed each time: a field name that recurs in every element of a desktop window's description, the field names of every page read, or text a research agent's reading had already had reviewed, when the assistant received it again. Now one review of a piece covers every place it appears while you are waiting for the same reply; a review that failed covers nothing, and a correction you send meanwhile starts the reviews over, as it already did for whole results. In recent chats this cut what the classifier reads by about a third. Each result's screening record states how many of its pieces were already reviewed.

Fixed

• When Nawa cannot shorten a long piece of work because saving part of it failed, the assistant now learns what happened to that save. To make room in a long turn, Nawa saves its finished older steps and puts a reference in their place; a coding agent first saves its whole transcript before going on from a shorter one. Before, when that save failed, the coding agent's failure said only "The coder transcript could not be stored before compaction.", and when the assistant's own request was then too large, its failure did not mention the save at all, although the request would have fit had the save worked. Now both failures state the save's own record: that Nawa's conversation database did not keep it and where in the project folder a complete copy was written instead, or the error when no copy could be written. The assistant reads this in the turn after its own request fails, and in a coding agent's result when the agent's request does.
• A long conversation that Nawa had already shortened no longer fails as too large for the model when Nawa cannot shorten it further. Nawa shortens a long conversation by having the Activity classifier model summarize its older part, and keeps that summary for the messages that follow. When the summary and the newer messages together passed the size at which Nawa shortens again, and Nawa could not summarize more, it set the kept summary aside and sent the whole conversation: when no classifier model was set up, when the classifier's server failed (the first time; during the minute after, Nawa used the kept summary), or when the newer messages it was sent differed from the saved chat. The message could then fail with "The complete request cannot fit safely in the selected model's context window." although the kept summary would have fit. Now Nawa sends the kept summary with the newer messages in each of these cases.
• A background build's coder can now use your plugins and connected MCP servers, as the coder in a chat turn can. Before, a build's coder was offered none of them: no plugin list and no way to load a plugin's tools. It now loads the tools it needs and asks with the same card as a turn, in the build's message, whenever the build's permission mode or the tool's own setting asks first. A local server is given the build's own folder, where the build works until it delivers its result to the chat.
• When an MCP server's sign-in or a connected Google or Microsoft account is turned down, Nawa now keeps the whole answer: its HTTP status, the kind of content and all of the content. Before, a refused MCP sign-in kept only a sentence, and an answer that was not JSON, such as a proxy's or a gateway's HTML error page, was dropped, so the sentence gave only the status, such as "HTTP 502". A connected account's refusal kept the first 2,000 characters of the answer and called a gateway's error page "invalid JSON", and an empty answer from the mail service read as a search that found nothing. Now such a page is reported as the failure it is, as in "google connector request failed with HTTP 502 Bad Gateway and returned a non-JSON response (1532 bytes, content type text/html)", an empty answer is reported as one, and the assistant can read the whole answer, which Nawa keeps as stored evidence when it is long. In Settings, an MCP server that refuses to register Nawa now reads like "Client registration failed with HTTP 400 Bad Request: …". When an MCP server's sign-in has expired and renewing it is refused, for example because access was revoked, the result of the assistant's next call to that server now includes the refusal; before, the call went out with the expired sign-in and nothing said why it was not renewed. An automation's failed snapshot of a connected account keeps the provider's answer with the run's failure. When signing in a Google or Microsoft account fails, the browser tab returns to Nawa with the failure's code and Nawa's log keeps the whole failure; before, the tab showed the raw error.
• A build's progress in the chat now picks up where it stopped after the window's connection to Nawa is interrupted, and nothing is lost. Before, the reply that follows a build started over from the point where it had first joined the build and got only the first 200 updates from there, with nothing to say that more were missing; whatever came after them never arrived. A build that finished or stopped while the connection was down stayed shown as working, with Stop the work in the message box, and its final report never appeared. A reply that began following a build more than 200 updates behind lost the rest the same way, and the line under a reopened chat's message that shows its build's state missed any change made while its connection was down.
• Nawa checks again whether a model takes forced tool calls, or a tool asked for by name, when it turned them off without the provider refusing them. Nawa makes the coder call a tool on a model that does so cleanly, and finds out once for each model and reasoning setting. In Nawa 1.0.81 and earlier, a check that failed for any reason turned forced tool calls off for that model for good, for instance one made while its server had no model ready (status 503), at a rate limit (429) or with a wrong key. In the same way, any error with status 400 on a request that asked for a tool by name, such as a refusal of an image, kept the model on required for good. Those findings kept only a note of the status. Now a finding stands only while the answer it keeps is a refusal: the provider's refusal of the tool choice, or for forced tool calls an error with status 500 or a reply that was not a single tool call. Nawa checks forced tool calls once more where any other finding stood, the next time they are needed, and keeps the new result, and asks for a tool by name again.
• When Nawa's capability research tests a model at different reasoning levels and a test request fails, the researcher now gets the provider's whole answer. Research & verify capabilities in Settings runs the model at three reasoning levels to see which ones change how much it reasons. Before, a failed test kept only the first 200 characters of the provider's answer, or of the error's message, with neither the provider's status nor the kind of content it answered with, so a rejected API key, a gateway's error page and an answer that was not the expected JSON were hard to tell apart. Now each failed test states the provider's status, the content type and the whole answer, or the connection error underneath with its code. A provider's refusal of Nawa's check of a model's reasoning and tool settings is now also read however deeply its answer nests: one nested more than about 2,300 levels deep made the check fail with "Maximum call stack size exceeded" in place of the provider's status and answer.
• The menu that the chevron beside Open opens, on an app's card or a delivered file, now lines up with the chevron's right edge. Before, it ended about 6 pixels to the right of the chevron, because Nawa measured the menu while its opening animation still drew it slightly smaller. For the same reason, a menu with no room below its chevron opened 2 pixels above it instead of 6, and a menu opened with a right-click on a card, a file link or text near the window's right or bottom edge came closer to that edge than the margin Nawa keeps there: the text menu could end half a pixel from the bottom of the window instead of 8 pixels.
• When a message fails because the conversation no longer fits the model's context window, the assistant now learns whether the provider's token counter failed on that message or earlier. After the provider's token counter fails, Nawa waits five seconds before asking it again and counts the messages in between itself. Before, each of those messages reported the counter's earlier failure as if the counter had just answered it, though the failure may have come from another chat, from one of the assistant's agents, or from Nawa's check of the model before sending. Now the failure says that Nawa did not ask the counter about this message, and when the failure it reports happened.
• When a message fails because the conversation no longer fits the model's context window, the assistant now learns why Nawa could not shorten it from the facts, not from a sentence of Nawa's. Nawa shortens a long conversation by having the Activity classifier model summarize its older part. Before, the failure said "Conversation compaction requires at least two complete rounds; no content was dropped.", "No complete older round could be compacted safely; Nawa preserved the full transcript.", or "The configured summarizer is unavailable", which it said when no classifier model was set up at all. A summary the classifier model's server turned down kept only the HTTP status, not the server's answer or address, and for the minute in which Nawa does not try again, every message repeated that failure as if it had just happened. Now the failure states how many rounds the conversation has and how many shortening needs; the size of each round, all of which fit in the recent part Nawa keeps word for word; that the classifier profile has no server address or model; the classifier's own error with the server's status and whole answer; the classifier's answer that Nawa could not use; or the sizes that kept a shorter version from being used. A failure Nawa is not retrying yet is stated as that earlier failure, with when it happened. The assistant reads this in the turn after the failure, and it is kept with the failed turn.
• Test connection on an image server's card in Settings now says what the image server answered when it turns the test down: its status and the reason it gives, such as "The image server answered HTTP 401: Invalid credentials". Before, the line gave the reason without the status when the server put it in a detail text or an error.message, said "[object Object]" for a validation error's list of problems, and otherwise said "HTTP 200", the status of Nawa's own check rather than the server's. That covered a reason given as an error text, as Ollama, LM Studio, Hugging Face TGI and xAI give it, Google's error inside a list, a reason in plain text, and an answer that gives no reason, such as a proxy's error page. Now the line quotes the reason the answer states, read the same way as a model provider's, and an answer that states none is reported by its status alone.
• When a provider turns down a request with a plain-text answer instead of JSON, Nawa now quotes that answer. Before, it gave only the answer's size and type. With no API key entered, loading DeepSeek's models in Settings said "Model-list request failed with HTTP 401 Unauthorized and returned a non-JSON response (31 bytes)." where DeepSeek had answered "Authentication Fails (governor)", and Together's "Missing API key" was lost the same way. Now the answer appears wherever Nawa shows such a failure: when Settings loads a provider's models or checks a model, under the message box, and in Nawa's log. Nawa quotes an answer whose provider declares it plain text or declares no type, up to its first 300 characters. An HTML page, such as the one the Hugging Face router sends, is still described by its size and type. The whole answer is kept as before.
• Nawa now takes a provider's refusal of a tool choice only from an answer that says so. When the assistant has to call one tool to finish, Nawa asks for that tool by name; a provider that accepts only auto, none or required as the tool choice refuses the name, and Nawa remembers this for the model and asks again with required. Before, any answer with status 400 counted as that refusal, such as a provider's refusal of a tool's definition or of an image it could not read, so Nawa asked again with required and kept the model on required for good. Now only a refusal that names the tool choice counts, with status 400 or 422 (servers built on FastAPI answer 422). Any other answer fails the turn as any failed model request does, and the turn's failure keeps the provider's answer. The coder is handled the same way: a provider's refusal of forced tool calls in the middle of the coder's work, which ended that work before, now turns forced tool calls off for that model and reasoning setting and asks again, as an error with status 500 already did. Whenever Nawa turns forced tool calls off for a model, its capability record, which bug reports include, now keeps the answer that decided it: the provider's status and whole answer, or the model's reply that was not a single tool call. Before, it kept a note such as "forced tool choice returned HTTP 500", and the answer to the coder's request was never read.
• Settings no longer says that a vLLM server does not declare how a model's reasoning is controlled when the server did declare it. A vLLM server describes the reasoning settings each of its models takes. When Nawa could use none of them, for example because the server had not been able to verify any, Nawa set the description aside. The note under the reasoning settings then said "The server reports a reasoning parser, but it does not declare how reasoning is controlled." or "No native reasoning parameter detected for this model.", and after you chose a model or pressed Test connection, the status beside the button said "No provider reasoning settings detected." Now both say "Nawa applies none of the server's reasoning declaration:" followed by the description as the server sent it, and the model's capability record, which bug reports include, keeps it. Nawa still sends none of those settings.
• A background build whose coder asks to run a command outside the sandbox now asks you with the same card a turn shows, in the build's message, and waits for your answer there. Before, the question reached no one: the build kept showing as working, with the command's card still running and nothing to answer, until you paused or stopped it. The build acts with the permission mode of the turn that started it, so a build started in Bypass permissions runs such a command without asking, as that turn would. Only you can answer the card. The time a build waits for your answer no longer counts toward its run's time limit, so a build you answer after a long wait no longer pauses as soon as its coder session ends. A build's tool cards also appear as the build works, where before they appeared only when the chat was shown again, and the cards of a build's later coder sessions no longer go missing then.
• When a provider turns down a request, Nawa now quotes the reason the provider gives, wherever its answer puts it. Before, Nawa looked for the reason only where most providers put it. Google's OpenAI-compatible endpoint sends its error inside a list, so checking a Gemini model with an invalid API key made Settings say "Capability discovery did not complete: Tool-choice capability probe failed with HTTP 400 Bad Request." without Google's "Please pass a valid API key". Providers whose servers are built on FastAPI, such as Mistral, Cerebras and a vLLM fleet, lost their reason the same way, such as "Invalid API Key" or "unknown model: …", when Settings loaded their models or checked a model, and so did a validation error's list of problems and a Cloudflare error list. A decision model's refusal in these forms said only its status, such as "HTTP 422", and an MCP server's sign-in, or a connector's sign-in or request, said "[object Object]" when the server's error held no message. Now each of these quotes the first message the answer states, and keeps the whole answer. An answer that states no message is reported by its status.
• Work that Nawa's watchdog stops for going quiet now ends with what the watchdog saw. A background build stopped because an agent helping its coder, such as the code reviewer, made no progress for the configured idle time failed with "Runtime error: This operation was aborted", as if it had crashed. Now it fails with a line such as "Stopped by the watchdog: no execution activity for 5 min during the code-reviewer dispatch.", and its record keeps the watchdog's facts beside the abort's own error: which limit ran out, its length or deadline, when it ran out, and the build's last activity before it. When the watchdog stops a chat's turn, the assistant's next turn gets the same facts, where before it learned only that the turn had ended with "This operation was aborted". An automation run the watchdog stops keeps them in its failure, which said only that too. Bug reports show them for every stopped turn, where they named only the kind of limit.
• When a request is too large for the model's context window, the assistant now learns why Nawa's count of it is an estimate. Nawa asks the provider to count a request when the provider offers that, and counts it itself otherwise, which can come out quite different from the provider's own count. Before, the failure said only that the count was an estimate. Now it also states the provider's answer when its counter failed, such as its status and whole message, or the error when Nawa could not read whether a vLLM server counts, and, for a count that adds Nawa's estimate to a total the provider reported, how much of it was estimated. The assistant reads this when one of its agents' requests is refused, and the next reply reads it when the assistant's own request was. Counting the assistant's own requests to a vLLM model whose settings could not be read also no longer treats the model as one that offers no counter.
• A message to a Main model whose provider refuses automatic tool choice now reaches the model, which answers without tools and says which capability it lacks when your request needs one. Before, the message box turned Send off for such a model, so a message you typed stayed in the box, and the note under the box showed the provider's refusal in red as though the connection had failed. Now that note is plain, and Settings still shows the refusal in red after Test connection.
• When a model's provider refuses to let the model decide on its own which tools to call (tool_choice "auto"), the assistant and Settings now state the provider's own answer. Before, Nawa replaced it with advice written for vLLM servers, "The provider rejected tool_choice=auto. Enable automatic tool calling and the model's tool-call parser on the inference server.", which is wrong for other servers, such as one built on FastAPI that does not take the setting at all. The assistant was given that advice as the provider's detail, cut after 500 characters, or "automatic tool calling unsupported" where there was none. Now the assistant gets the provider's status and whole answer, or the vLLM server's model settings when they turn automatic tool choice off, and Settings and the message box say "The provider refused tool_choice=auto with HTTP" followed by the status and the answer. When a provider refuses the tool the assistant must call by name, the model's capability record, which bug reports include, now keeps the whole answer, where it kept its first 160 characters. Nawa checks every model again once after this update, so a refusal recorded before is stated the same way.
• Settings now says when Nawa could not find out what a model supports. After you chose a model or pressed Test connection, the status beside the button said "No provider reasoning settings detected." as a success even when that check had failed, for example because the provider rejected the API key or could not be reached. It now says, in red, "Capability discovery did not complete:" and the error, in the same words as the note under the reasoning settings. When the server URL was not a complete http:// or https:// address, such as localhost:1234/v1, the check stopped before it reached the provider and Settings lost the error: the note asked you to test the connection you had just tested. Now the note and the status both give the error.
• Windows no longer grows slower the more commands Nawa runs. Each command Nawa runs in its sandbox gets a private desktop, and that desktop was made on the same window station as yours. Windows' Desktop Window Manager, which draws every window on the screen, keeps some state for each desktop ever made there until it restarts, and its work for every frame grows with that state. Over hours of commands, opening, switching and minimizing windows in every program lagged and the mouse stuttered, until the Desktop Window Manager or Windows was restarted. In a measurement, the desktops of 4,000 commands took it from a fifth of a processor core to a whole core. Now each command's private desktop is on a separate window station, which the Desktop Window Manager never draws, so commands cost it nothing. Each command still gets its own private desktop.
• Nawa now reads every reasoning level a provider lists when it turns down Nawa's check of a model's reasoning settings, whatever words the provider uses. To learn which levels a model takes, Nawa asks for a level no provider has and reads the levels the refusal names. Before, it searched the refusal's raw text for a few expected phrases. From a vLLM server it lost the list's last level, Max, so Max was not offered and a model set to it ran at the provider's default. Google's list ("Valid values are: …") was not read, so only Low, Medium and High were offered. Ollama's refusal was not recognized at all, so Nawa checked the model again on every request, and the assistant and Settings were told the check had failed. Now Nawa reads the provider's own message and offers each listed level that Nawa can send. A refusal that names neither the setting nor the level Nawa asked for, such as one about a different setting, now counts as a failed check instead of as "no reasoning setting".
• A chat you open before its messages have loaded now keeps what you do in it while they load. Before, once they arrived, Nawa put back the chat's saved draft and review comment if a message you sent meanwhile had taken them: the sent text became the chat's draft again, filling the box the next time you opened the chat or restarted Nawa, and the review comment stayed in the box, so the next message sent it a second time. A review comment you dismissed or a draft you cleared while the messages loaded came back the same way, also after a restart, and a chat you had not opened since Nawa started stayed linked to a saved artifact you deleted. A chat that received messages after Nawa started, such as an automation's report, also opened with them but recorded as older, so editing one of its messages right after opening it kept every message after the edited one instead of replacing them with the new reply.
• The plugin views menu, which the plugin icon at the top right of a chat opens, keeps its items when Nawa reloads your plugins without a change to their views, as it does when you go back from a plugin's settings or an installation finishes. Before, every reload replaced the menu's items: a view you were clicking at that moment did not open, and the item you had moved to with the arrow keys lost the focus, so Enter did nothing.
• An error from a model's provider is no longer taken for the model's answer about its settings. Nawa asks the provider which reasoning settings a model takes, whether it can call tools, and whether it can be made to call one. Before, an error in reply, such as a rejected API key, a model the server does not serve, a rate limit, a server with no copy of the model ready, or LM Studio's "No models loaded", counted as the answer. Settings said "No native reasoning parameter detected for this model.", the assistant was not told the check had failed, the provider's status and message were dropped, and one failed check of forced tool calls turned them off for that model for good. Now the assistant and its agents get the failure with the provider's status and whole answer, Settings shows it, and Nawa checks again on the next request. A failed check of forced tool calls decides nothing and is kept in the model's capability record, which bug reports include. A server that answers an invalid setting with status 422, as servers built on FastAPI do, is now read like one that answers 400.
• A background build no longer fails with "Runtime error: This operation was aborted" while its coder is still working, after the coder has had another agent, such as the code reviewer, help it. When that agent finished, Nawa left a timer running that the build's further work never reset, and the build stopped when it ran out: 22 minutes after the start of the coder session that asked for help, or, when the agent finished after that, 5 minutes after it finished, whether the build was then in that session or a later one. The coder's sessions also had a 20-minute clock of their own: after it, every request for another agent's help was refused with "No authoritative progress was recorded before the configured progress window expired", however busy the coder was, and some of the ways Nawa recovers when a model's answer breaks off were no longer tried. A model's capability research, started with Research & verify capabilities in Settings, stopped the same way 5 minutes after another agent helped it. An agent that stops answering is still stopped once its configured idle time passes.
• When a file you attach cannot be read, the assistant now learns why. Before, in an ordinary chat it learned only that reading the file had failed: the reason never reached its list of the attached files, and listing the chat's uploads gave none either. An automation that read the chat got only a short message, cut after 1,000 characters, and for a file with nothing but blank lines a sentence Nawa made up, "Native extraction failed without an error detail." Now the assistant gets what the document reader reported, its run and its output, or the system's own error when the file could not be recorded in the chat's folder, and nothing is made up. A successful upload is unchanged. A failure too large to repeat with every message, such as one that holds the reader's whole output, is saved in the chat's folder, and the assistant gets its beginning and where to read the rest.
• When Nawa cannot find out what a model supports, the model now gets the whole failure. Nawa asks the provider which reasoning settings a model takes and whether it can call tools, and asks a vLLM server for the model's settings. Before, when that check failed, the assistant and its agents were told only the error's first line, such as "fetch failed", cut after 600 characters, or a sentence of Nawa's own, such as "The capability probe did not complete." The same went into an agent's report to the assistant, into what a document read says about transcribing its scanned pages, and into the refusal to read an image from the web when the model's image support is unknown. A refusal from the provider kept only 300 characters of its answer, and a vLLM server's refusal or unreadable answer kept nothing. Now each of these states the system's own error: which check failed, the connection error underneath it with its code, the proxy Nawa went through, or the provider's status and whole answer. Settings shows the same note as before when a vLLM server does not return a model's settings.
• When the assistant reads a PDF page that has little or no text and Nawa has no picture of that page to transcribe, the model now learns why, once for the whole read: which pages the document reader drew, and the reader's own error and output when it could not read the document, or its report of each page it could not draw. Before, every such page got the same fixed sentence. The document reader also no longer loses the pictures of a PDF's other pages when one page cannot be drawn, describes a page whose text it cannot read as such instead of as blank, and reads and uploads a PDF whose drawing makes it print a warning, such as a chart with a damaged drawing instruction, where it used to fail.
• Nawa no longer adds a .gitignore file to a folder when it creates the folder's Git repository, as it does for a chat's own folder, a project folder that had no repository, or a chat started from a saved artifact. Checkpoints in such a repository still leave out node_modules, __pycache__ and .venv; that rule now lives in the repository itself, in .git/info/exclude, and a repository you made keeps only its own rules, as before. Before, the file was added to your folder and committed with the first checkpoint, and since no code checker reads it, the coder's code checks in that folder never counted as complete on their own.
• Opening a chat while Nawa is starting no longer loses what you typed in the message box, or saves it as another chat's draft. Before, clicking New chat before your chats had loaded emptied the box, and once they loaded the new chat disappeared and the chat that had been open came back. Clicking New chat, or opening another chat, while the open chat's messages were still loading saved what you had typed as that chat's draft, in place of the draft it had saved. Now the chat you open keeps what you typed, after any draft it had saved, and stays open; the chat that was loading keeps its own draft; and a message you sent before then goes to the chat you opened. A file you attach before a chat has opened is now saved in the folder of the chat it goes to, as files attached later are; before, one attached before your chats had loaded was saved in no chat's folder.
• When a document read fails, the model now gets the whole failure. Before, an error inside the document reader was cut after 400 characters, so a read that named a sheet the workbook does not have listed only some of the workbook's sheets, and the error came without the reader's own report of it. Now the model gets the whole message and that report: what kind of error it was and where in the reader it happened. When the transcription of a scanned page cannot start, because the document cannot be read again, its pages cannot be drawn, or the model's image support cannot be looked up, the model now gets the system's own error, and when drawing the pages failed, the document reader's exit code and output, where it got a fixed sentence or only a message. When a Files drawer preview fails because the document reader stopped, its details now state the reader's exit code and output once, where they stated them twice.
• A failed tool now always gives the model a failure code it can recognize. Before, when the error behind a failure carried a number, that number became the code. A document reader that exited with status 1 or 7 gave the code "1" or "7" when the assistant or the coder inspected or read a document. An operation that was stopped gave "20" and one that ran out of time gave "23", and a language server's error gave its protocol number, such as "-32601". The same happened to an agent's work or a background build ended by a stop or by its time limit, to the screening of content from outside sources, and to a web page, a picture or a file to show that did not answer in time. An automation run that stopped making progress also saved "20" as its error. Such failures now carry the tool's own code, a web page that does not answer in time is reported as a timeout, and the number is still reported with the rest of the error.
• When Nawa inspects a file for the model on its own, a failure now reaches the model whole, as it does when the model inspects the file itself. Nawa does this for the files attached to your messages, for the chat's uploads when the assistant lists them, and for the files the assistant hands to the coder. Before, such a failure kept only a short code, such as "ENOENT", or only its message, cut short, and a document the reader could not open, such as a damaged PDF, was described as if it had been read, so the model learned of the problem only when it tried to read the document. Now the model gets where the file's name pointed and what is there, the system's own error, or the document reader's own result and output. An upload whose copy in the chat's folder cannot be written now keeps the system's error the same way, and so does a document read whose transcription of scanned pages fails outright.
• When the assistant or the coder names a file that turns out not to be a readable file, the refusal now tells the model where the name pointed and what is there: the system's own error for a missing file or one Nawa may not read, or the fact that it is a folder. Before, handing a background build a missing file, a folder or a file Nawa may not read gave the same "No readable file exists" message for all three. Viewing an image called a folder a missing image, inspecting or reading a folder as a document said only "illegal operation on a directory", and showing a file in the chat did not say where its name pointed. Showing a file from outside the chat's folder that Nawa may not read also said that the file did not exist.
• A link to another chat's file is no longer taken for this chat's file of the same name. Before, when the assistant or the coder viewed an image or inspected a document by such a link, or the coder opened one in its browser, Nawa used the file of that name in this chat's own folder, and the image tool's result named it as the other chat's file. While the coder built or revised a saved app, it used the file of that name in the copy of the chat's files it works on. Such a link reaches a chat when you paste one from another chat. These tools now refuse it and tell the model which chat and file it names, as they do for other links they cannot use; links to this chat's own files work as before, in a project's folder and in the coder's copy too. The chats of one project share its folder, so a link to another of its chats' files names a file this chat has as well; it is refused all the same, and the model can use the file's path instead. The Files drawer likewise no longer shows this chat's file for an address that names another chat's file. A background build works in a folder of its own that belongs to no chat, and still takes any chat's link for that folder's file of the same name.
• A message you send while Nawa is starting, before your chats have loaded, now goes to the chat that opens. Before, pressing Enter or Send then did nothing and said nothing, and the message stayed in the box. A second message sent before the chats load is queued and sent after the first, as one sent while a reply is being written is, and what you type after sending stays in the box, after the draft the chat had saved. A message sent while the open chat's messages were still loading also took the chat's review comment with it, and the comment then stayed in the box, so the next message sent it again. The comment now shows in the box once the chat has opened, and goes with the next message you send.
• When a tool refuses a file that the assistant or the coder named, the refusal now tells the model what the name pointed to and why it was refused, so the model can correct it. The name may point outside the chat's folder, at another chat's file or a saved artifact's file, at an address with no file in it, or at a kind of address the tool cannot read. This holds when viewing an image, inspecting a document, revising a saved app and handing files to a background build. Before, these refusals kept only a general code, such as "The image reference does not resolve to this workspace.", and a build handed several files was not told which one was refused.
• A sandboxed command no longer fails because another command's sandbox was ended partway, as happens when a command is stopped or Nawa closes while commands run. A sandbox ended while it held the shared record of folder access labels gave that record up before Windows had closed its copy of it, so a command waiting for the record could not read it and stopped with "The process cannot access the file … labels.json because it is being used by another process", before it started or after it had run. The review of a chat's changes was then unavailable for a moment, and the coder's finished work could be rejected. A sandbox ended while saving the record could also delete it, and the next one started from an empty record, without the original labels it had to put back. Nawa now saves the record in one step, so it is never missing, and reads it while an ended sandbox's copy is still closing. A command could also fail the same way as it finished, when another command's sandbox was checking at that moment whether it was still running; that check no longer gets in its way.
• A saved artifact's files now open in the drawer whenever they are there. Before, when its Files opened before the artifact's app had run, or after the artifact was saved again, the drawer could say a file "no longer exists in this workspace" although it did, or list the artifact's files with some missing. The drawer reads the file list and the file at the same time, and each read began making the artifact's runtime copy, the copy its app runs in and its Files shows, over the others, so most failed against each other or read a copy still being made. A copy left incomplete that way stayed so, for the app too, until the artifact was saved again. Saving a new version also deleted the copy a read was still using, and the copy an automation of the artifact was running in. Nawa now makes each copy once, in a folder beside its place, and moves it into place only when it is complete; a save removes an older copy once the reads using it have finished, and leaves a running automation's copy alone; and a copy an earlier version of Nawa left incomplete is made again. When a copy cannot be made, the drawer now shows what failed instead of saying the file no longer exists.
• A prompt you steer into a running reply is now remembered by the replies that follow. Before, only the reply you steered received it: every later request gave the model that turn's prompt and answer without it, so a correction such as "use Vue instead" could be lost on the next message, even though the chat still showed it in the turn. The agents and the coder that later replies start never received it either. Nawa now gives each later request every steered prompt the turn applied, exactly as you wrote it, between that turn's prompt and its answer and after the plan the assistant had stated before you steered. Research agents count it among your own messages, and when a long conversation's older turns are summarized, the summary is written from them with the steered prompts in place. A long reply also no longer drops its steered prompts and its opening plan from the saved chat when its activity record reaches its size limit, and the assistant's plan is now always recorded before the steered prompt that followed it.
• An image or file link in a message whose address names a saved artifact's file, as the Files drawer's addresses for an artifact's files do, now shows and opens the artifact's own file. Before, the image showed the chat's file of the same name, and the link downloaded that file, opened it in the drawer, showed the chat's folder and offered to open it in another application. Now Download gives the artifact's copy, Open in folder shows the artifact's folder and the drawer opens the artifact's file, which, as in the drawer, offers no application because an artifact's files are read-only. A link to a file's preview address now works like a link to the file itself. The assistant's tools no longer take such an address for the chat's file either: showing it, editing it as an image or handing it to an agent now fails with the chat, the artifact and the path it names, and an answer that links one is no longer accepted just because the chat has a file at that path.
• What you type or attach in the message box while Nawa is starting now stays when your chats finish loading, after the draft the open chat had saved. Before, loading the chats put that saved draft back in the box, or emptied it, and what you had typed was lost. The same happened to what you typed into a chat you opened before its messages had loaded, and when changing the chats folder in Settings failed.
• The sidebar's sections are evenly spaced again when the last project in Projects is open and holds chats. Before, the space kept below that project's last chat was added to the space between sections, so the Chats heading sat 4 pixels lower than every other section heading. A pinned project's chats also ended with twice the usual gap before the next pinned chat. A project's chats keep their gap below the project's folder row and before the next project.
• The coder's questions to the Python language server now follow changes to Pyright's configuration and to type stubs. Pyright reads pyrightconfig.json, the [tool.pyright] section of pyproject.toml and .pyi stub files itself, and learns that they changed only when it is told, which Nawa never did. After a command added a folder to extraPaths, or added, changed or deleted a stub, Pyright kept answering from the old files for as long as it ran, and Nawa reported its answers as complete: an import the new configuration resolved was still reported missing, a stub's types were ignored, and a deleted stub still appeared among a function's uses. Nawa now tells each language server of every change to the files it asks to be told about, before each question and as Nawa's own tools make changes, and answers once the server has reported on the file asked about since. No language server says when it has finished acting on such a change, and Pyright applies an edited configuration only a moment after hearing of it, so Nawa waits for the server's own report; after a change the server does not act on, such as an edited README, the first question about one of its files can take until 10 seconds after the change, the language server's time limit.
• Images the assistant generates, files it imports, and files that a connector or plugin running on this computer writes into the chat's folder are now saved in the reply's checkpoint with the assistant's other changes, so you can review and undo them. Before, Nawa began keeping track of a reply's changes only at the assistant's first file edit or shell command. A file one of these tools wrote earlier in the reply was saved as a change made outside Nawa, which undo leaves alone, and a reply that used only these tools saved no checkpoint at all: its files stayed out of every checkpoint until a later reply saved them as changes made outside Nawa.
• What you type in the message box now stays when new messages load into the open chat, such as an automation's report or a message added from another window. Before, loading them put back the draft the chat had when you opened it, and what you had typed since was lost.
• After you send an instruction to a paused build, its progress now stays live in the chat until the build stops again. Before, the reply that follows the build ended at once, or after about four seconds with "I was interrupted before I could finish. Would you like me to continue?", while the build went on working with nothing in the chat showing it. Reloading the window during that reply ended it the same way.
• An instruction you send to a paused build now stays in the chat you sent it from, also when you open another chat while it is being sent. Before, the instruction and the build's live progress appeared in the chat you had opened and were saved in its history, while the build's own chat never showed the instruction; if the chat you had opened was running a reply of its own, its Stop button disappeared. An instruction sent while its chat's history was still loading after a restart reached the build but was missing from the chat afterwards; Nawa now loads the history first, and if it cannot, the instruction is not sent and comes back to the message box with the reason.
• When a request to an MCP server or its sign-in, the email and calendar connectors, the decision model, token counting, an image server, a plugin download, the model list in Settings, a bug report upload or a workspace app's health check fails before any answer arrives, its error details now keep the whole error, as tool failures already did: the network's own code, such as ECONNREFUSED for a refused connection, or UND_ERR_ABORTED with "Proxy response (407)" for a proxy that wants a password, and which way the request went, through which proxy or directly, with what each proxy lookup answered. Before, they kept only the outermost message, "fetch failed", or the one below it, which for a proxy's refusal read "Request was cancelled.", and a bug report stopped by such a proxy was given the code "TypeError". The messages Settings and the bug report dialog show are unchanged. When an MCP server's sign-in cannot find where to sign in, the error now lists each address Nawa asked and what it answered or how it failed, and a sign-in that fails after you approve it writes its whole error to Nawa's log. A local connector that cannot start now reports the failed system call and the path it concerned.
• The drawer's actions for an Office document among a saved artifact's files now act on the artifact's own file. Before, Open in Word (or Excel or PowerPoint), Open in folder and Download used the file of the same name in the chat's folder: they opened, showed or downloaded that other file, or failed when the chat had none. Now Open in folder shows the artifact's own folder, and the drawer's header offers it for every file of a saved artifact too; Download gives the artifact's copy. An artifact's files are its saved snapshot and stay read-only, so the drawer no longer offers to open them in another application, where saving would change the artifact; download a copy to open it there.
• When one of Nawa's own steps on a workspace's git repository fails, the coder and the assistant are now told which step it was, with what Nawa observed beside it. Before, when the command sandbox failed before git could start, as it did while every sandboxed command was being refused, the coder's attempt to finish its work returned an error with an empty message: only a general git failure code, with the sandbox's own explanation deep in its details, so nothing said that the failed check was Nawa's rather than a problem in the coder's work. The error now says, for example, "Workspace git repository check failed.", and keeps the sandbox's details as it reported them. The same holds when Nawa reads the repository's history, counts its commits or lists its uncommitted changes or checkpoints, when it looks up where a symbol is defined, and when a language server times out or exits while it starts or answers.
• A message you send now leaves the message box as soon as you send it, with its attachments and any review comment on it, so whatever you type or attach while it is still being sent stays in the box as your next message, and Enter sends only that. Before, what you typed in that moment was added after the sent text, which stayed in the box with its attachments, and pressing Enter again sent that text a second time. If you had moved to another chat meanwhile, or sent an instruction to a paused build, what you typed was erased instead. A message that cannot be sent comes back to the box in front of anything typed since, with its attachments and review comment, and the send button no longer shows it as still sending.
• A drawer tab whose sheet, image, PDF or Office file has been deleted now says "… no longer exists in this workspace" over the workspace's files, as a text file's tab already did, and reports nothing to the error log. Before, a deleted sheet said "Can't Display Data. Nawa could not build a preview of this file. The file itself is unchanged." and was logged as an error, a deleted image said its file was "still available in the workspace", a deleted PDF showed the server's raw answer, and a deleted Office file offered to open it in Word. The drawer now reads every kind of file before it shows it, including on Refresh, so a shown file that is deleted also gives way to the workspace's files. A file that is there but cannot be displayed stays open with one line, "Nawa could not display …", whatever its kind. Images in a saved artifact's files are now read from the artifact, like the rest of its files, not from the chat's own folder.
• Two drawer tabs saved for one file by an earlier build now come back as one tab, the one that was shown, and a files tab that opens a file another tab already shows takes that tab's place. Tabs for different files with the same name, or for an artifact's copy of a file, are kept.
• The assistant's own changes to a chat's files are now a checkpoint you can review and undo, as the coder's are. Before, when the assistant wrote or edited files itself, with its file tools or a shell command, Nawa never saved them as a checkpoint: after the reply the files-changed pill still showed the last file's name instead of "1 file changed", asking to undo was refused because the files had changes outside any checkpoint, and the next time the coder ran, even only to look at the project, its checkpoint took in the assistant's changes as its own, so undoing the coder's work undid them too. Nawa now saves the assistant's changes as the reply's checkpoint when the reply ends, whether it finished, failed or was stopped, and before the coder starts. Undo counts these checkpoints with the coder's. Changes made outside Nawa, such as your edits in another editor or files you upload, are no longer taken into Nawa's checkpoints: when Nawa saves a change of its own, it first saves them as they were, separately, so undoing Nawa's change keeps them, and when Nawa changed nothing they stay as you left them. The files-changed pill now shows the latest checkpoint's changes; before, in a project folder with its own Git history, it could show your own latest commit, or, after the assistant only ran a command, every file already in the folder.
• A restart of Chromium's network service no longer cuts Nawa off for a minute from a model provider, or another service it must reach through a proxy that your Windows settings or a PAC file require. A proxy lookup that is running when the network service restarts comes back empty; before, Nawa took that for "connect directly" and kept it for a minute, so every request to that address went around the proxy and failed until the minute was over. Nawa now asks again at once and keeps only an answer that names the route. If the second lookup gives none either, because it too comes back empty or takes more than 5 seconds, only that request connects directly, and the next one asks again. A failed request's error details and Nawa's log now also say which way it went, through which proxy or directly, and what each lookup answered.

1.0.81 — 2026-09-30

Fixed

• A command's sandbox that ends while it prepares its folders' access labels, as every one does when Nawa closes, can no longer stop all later commands on the computer from running. When such a sandbox had already come across a file with a label of its own, such as the key file that encrypts your settings, but had not yet recorded it, every later sandbox took that label for another program's change and refused to start with "Integrity label changed outside the active lease", until the file was relabeled by hand. The coder, unable to run anything in the sandbox, could then run its commands outside it. Nawa now records such a label as the file's own the next time it finds it, and gives it back when no command needs that folder any more; while a command's folder needs a different label, the file carries that one. A sandbox that ends this way in a folder where you may change files but not take ownership of them, such as C:\Dev, can also leave a temporary permission on a file: the next command in that folder now removes it, where before only a command in another folder did.
• The files-changed pill above the message box now shows the assistant's own changes while it works, as it does the coder's. Before, when the assistant wrote or edited files itself, with its file tools or a shell command, instead of handing the work to the coder, the pill stayed hidden during the reply and afterwards: the chat's workspace had no change history to compare against until the coder first ran, and the assistant's file edits did not say that they had changed anything. Nawa now starts the workspace's change history before the assistant's first change in a reply, as it does before the coder starts.
• When the assistant or the coder looks at an image that is not a PNG, JPEG, GIF or WebP file, such as an SVG chart, an icon or a BMP, Nawa now sends the model a PNG drawing of it, and tells the model so, with the image's own format and both sizes. Before, Nawa sent the file as it was, and a model server that could not read it, such as vLLM given an SVG, rejected the whole request, so the turn ended with "Model request failed". An image Nawa cannot draw either, such as a TIFF, is now left out of the request, and the model is told why, with the image's format. The same holds for images attached to a message, images a connector returns, image links read from the web and images given to the image generator to edit. Nawa now recognizes an image by its content rather than its file name: a PNG saved under another extension can be viewed, and a file named .png that holds something else is no longer sent as a PNG. SVG images on a web page are now listed with its other images.
• The coder's questions to a language server are now answered from every file of the project in that server's languages, as each file is on disk. Before, a JavaScript or TypeScript project without a tsconfig.json or jsconfig.json was answered from the files already open and what they import, while the answer said it was complete. Asked for the uses of a function, Nawa then returned only its declaration and missed the files that import it or call it as a global from another script on the page. A rename preview changed only the declaring file, which would have left every caller broken. A file changed or deleted by a command could also be answered from its old text, by the TypeScript server once it had opened the file and by the Python server in any case. A rename then computed its edits from lines that had moved, and a deleted file still appeared among the uses. When a project has more files than code intelligence lists, or a file too large to give the server, the answer now says which, and is marked incomplete.
• After the coder edits a TypeScript or JavaScript file and the file has no errors, Nawa's diagnostics now report it as checked. The TypeScript language server sends no new report on a file that stays free of problems, so before, Nawa listed such a file as unchecked however often the coder checked it, and a coder that had made a correct edit could not finish on the diagnostics check. Nawa now reopens the file in the language server, which reports on every file it opens. Diagnostics also no longer miss an error that an edit to one file causes in another: before, a file that had not changed itself kept its earlier report, so changing a function's parameters could leave its callers reported clean. And the fixes the coder is offered for a file after an edit now follow its current diagnostics, where before they could follow its diagnostics from before the edit.
• A reply you stop now ends once, as stopped: it says "I was stopped before I could finish" and keeps what the assistant had written in its Unverified draft card. Before, Nawa recorded the stop as a failure of the model's stream (code "20") and ended the reply twice, once from your stop request and once from the reply itself. When the stop request's end came first, for example while the assistant waited on a web search or a connector that does not stop at once, a reply stopped from another window, or reloaded before it ended, showed a red "Response stopped" notice. Nawa now records what stopped a reply (your Stop, Nawa closing, the chat's deletion, or the window losing its connection), and the assistant's next turn receives it with the answer written so far, also when Nawa closed during the reply. A reply whose assistant waits on something that does not stop at once ends a second after the stop.
• Local connectors and plugins, such as Chrome control, are now told the workspace of the chat that uses them as the folder they may work in, so Chrome control can save a screenshot to a path in the chat's project folder or, outside a project, the chat's own folder. Before, Nawa told them no folder, and Chrome control refused every path outside your temporary folder, the chat's workspace included. A connector works for one chat at a time: when another chat uses one that has read its folder, it restarts for that chat, and Chrome control's open pages close. Any other folder is still refused, and so is a relative path, which Chrome control resolves in its own folder. Remote connectors are told no folders of this computer.
• When Nawa closes the coder's browser, at the end of coding or when the coder closes it, it now reports each part of the close that failed: reading the page's final list of errors, closing Chromium, and stopping the app the browser had started. Before, the close always reported success, so the coder's work could be accepted as cleanly finished while Chromium or the app's server was still running, or Chromium's temporary profile folder was left behind. Deleting a chat now reports an app of the chat that did not stop, and every other close or app stop that fails is written to Nawa's log, such as an app stopped because it sat idle, was restarted, or Nawa quit.
• When the coder asks a language server where something is defined or used, what implements or calls it, how to rename it, which fixes apply or which symbols the project has, Nawa now waits until the server has analyzed that file. Before, a question asked right after the server started could be answered from the open file alone and still be reported as complete: asked for the uses of a TypeScript function, Nawa returned only its declaration, and a rename preview changed only that file, which would have left every caller pointing at a name that no longer exists. Pyright answered the same way before it had listed the project's files. If the server still hasn't analyzed the file when the request's time runs out, the answer is marked incomplete and names the file.
• When a background command finished while the coder was checking on it, Nawa could report it finished and complete but point to a copy of its output taken while it still ran, marked incomplete, which could lack its last output. Nawa now reports such a command from its finished state, with all of its output. The same was true of processes a command leaves running when it exits, which Nawa follows in the background: if they finished while Nawa was reporting the command, the report said they had stopped but carried the earlier copy. A report that a command is still running also no longer shows the command's exit in its log excerpt, and its runner facts stay as they were when the report was made; before, they could change afterwards to say the runner had finished.
• When coding ends, Nawa now asks every background command to stop at once, and reports each one stopped when its sandbox has closed. A sandbox can close seconds after the request: one still preparing its command, while it waits its turn for Nawa's lock on file permissions for example, acts on the request only once it is ready, and one cleaning up waits for that lock to restore the access labels it gave the workspace. Nawa waited 2 seconds for each command in turn, then reported one still closing as not stopped, giving the sandbox's confirmation that the request had arrived as the error, so the coder's finished work could be refused as not finalized. Commands later in line kept running while Nawa waited for the earlier ones.
• When a language server's rename or code action would also change a file outside the project folder, the coder now sees every change it proposes: each file, position and new text, with files outside the project marked as outside it, as in the other code-intelligence answers. Nawa still does not apply such an edit, since it applies an edit only when all of it lies in the project; the coder can make the changes with its other tools as its permissions allow. Before, the coder was told the edit would create, delete or rename files, which it would not, and saw neither what it would change outside the project nor what it would change inside it. A code action that Nawa does not apply is now listed with the reason and changes that applying it would return.
• A command that Nawa stops before its sandbox has started it is no longer started. The stop can come while the sandbox still prepares the command, waiting its turn for Nawa's lock on file permissions, for example: when you press Stop, when the command's time limit passes, or when a language server or connector takes too long to start. Before, the sandbox looked for the request to stop only once the command was running, so it started the command anyway and ended it right after, and the command's result said it had started. Now the result says it never started.
• When the coder asks what calls a function or what it calls, and the language server finds more than one declaration there, such as a namespace declared in two files or an interface method declared in two places, every declaration now appears with its own calls. Before, Nawa kept only the first and left out the rest without saying so: asked about a namespace in the second of two files, it answered with the first file's. If the language server fails to list one declaration's calls, that error now appears on it and the other calls stay in the answer; before, the whole answer failed. The answer also lists only the directions the coder asked for, where before it showed an empty list for the other, and says of each list whether the result limit shortened it.
• When a language server's rename, formatting or code action fails, the coder now receives the error's own code and details, and which language server proposed the change, as it does for the other code-intelligence requests. Before, it received only the error's message: for example, not the code Pyright returns because it does not format Python, nor that a proposed change was to a file that does not exist. A code action that fails this way is listed with its error beside the others; before, it made the whole list fail. When writing a change to several files fails, Nawa now restores only the files it changed, and tells the coder the project is partly modified only when it is. Before, a read-only file whose write had failed, and which was therefore unchanged, was reported as not restored, so the coder was told the project was partly modified when it was not.
• When the coder asks for a rename, a formatting change or the code actions for a file and no language server is running for it, it now learns why, as it already did for type information, implementations and calls: which servers are set up for which kinds of file, and why one that is not running is not, for example because its program was not found or because it exited while starting. Before, it received only a sentence saying that no language server was available. The servers' state in these answers now also says how soon Nawa will try again to start a server that failed to start, and whether Nawa has shut the servers down; before, a server Nawa would try again a minute later looked the same as one it had given up on. A language server that exits while the coder waits for its answer now ends the request at once, with the server's exit code; before, the coder waited out the 10-second limit and was told the request had timed out.
• When Nawa turns down the coder's finish after it has already begun wrapping up the work, for example because saving the project's checkpoint failed, the coder's language servers now start again when it next needs them. Before, they stayed shut down for the rest of its work: its requests for type information, renames or formatting found no language server, definition and reference lookups fell back to reading the files, and diagnostics to syntax checks.
• When Nawa does not apply a language server's rename, formatting or code action, the coder now receives the proposed change with the reason as facts: which two edits overlap, how many edits there are beside the configured limit, which edit falls outside its file, and, for a change to a file that does not exist yet, such as code moved to a new file, what would have been written there. Before, it received a sentence, such as that the edits overlap, and none of the changes. Refusals also no longer tell the coder what to do next: applying without the current preview returns that preview, whose file hashes show what changed since, and a disabled or unknown code action is refused with the server's reason or the action it named. An edit that ends before it starts is now reported as that edit's error, not as an overlap.
• When the assistant or the coder reads a saved result that fits what the model can recall at once (about 7,000 tokens with a 100k-token model, about 20,000 with a 256k-token one), it now receives the whole result. Before, a saved result larger than about 3,800 tokens came back as a shortened copy with a pointer to read it again, and following that pointer returned a shortened copy of the copy, so the complete result never arrived unless the model asked for pages itself.

1.0.80 — 2026-09-29

Added

• The documentation has a Settings section: an overview and one page for each tab of Settings, with screenshots and an explanation of every setting on it.
• A bug icon at the top right of the chat, and a Help menu with Nawa Help (this documentation on nawaagent.com) and Report a Bug…. A bug report goes to the Nawa team at nawaagent.com with your message and, if you add it, your email, and the dialog shows the report's reference.

Changed

• An agent the assistant hands work to gets a list of the assistant's earlier steps in the turn: for each, what it asked for, how it ended (a command's exit code, for example), how large its result is, and a way to read the whole result. A failed step shows up to about 1,000 tokens of its details instead of 4,000, so about four times as many large failures fit before the coder cannot start: 49 instead of 12 with a 256k-token model. Before, a step that succeeded showed only that it succeeded, so a command that exited with an error code looked like a plain success.
• Reading a saved result, a web page or a skill returns as much as the model asks for, up to what its context keeps word for word, about a quarter of it (63,000 tokens with a 256k-token model). Before, a read returned at most 8,192, 12,000 or 16,000 tokens, so GitHub's 270 KB page for a missing repository took 15 reads; now it can take 2. A saved result read without a size comes in pages of 70% of the model's recall budget, no longer capped at 8,192 tokens, and includes what the step asked for. A skill's instructions and files arrive in the pages the skill reader makes; before, a page over about 3,800 tokens arrived as an excerpt that had to be read again.
• The documentation uses Nawa's own icons, and its sidebar sets each section's pages beneath it, as the app's sidebar does.
• code-reviewer and fact-checker are built-in agents: they can be customized and restored, but no longer deleted.
• Every release includes the full installer, Nawa-Web-Setup-<version>.exe, and the install guide names it. The update package, Nawa-Setup-<version>.exe, refuses a computer without Nawa and names the full installer instead.
• A bug report covers only the chat that is open: from Nawa's logs, that chat's lines and the lines that belong to no chat; of the lines earlier versions wrote, which did not mark their chat, only those naming it. It leaves out your computer's name, shows Tailscale addresses and device names as numbered placeholders, and shows your Windows user folder as %USERPROFILE%. Before, it held the newest log lines of every chat, and the last runs of every automation with their results.
• The assistant proposes a memory during its reply, quoting your words, when you ask it to remember something or state a lasting preference, correction or fact. The proposal appears under the answer with Save and Dismiss, or already saved when Save new memories automatically is on, and a note that corrects an older one replaces it until deleted. Before, after every reply the background helper was sent your message and the answer to look for things to remember, and what it found appeared only on the Memory tab.

Removed

• Documentation and Debug in Settings → General; the Help menu replaces them. A bug report can no longer be sent to a Tailscale device or saved on this computer.
• The Admin button and its accounts panel. The engine refuses every admin request, so the panel could not work; it appeared in a browser paired through remote access.

Fixed

• The check Nawa runs on its command sandbox before the first command no longer freezes Nawa while it runs, and no longer reports a working sandbox as unavailable while it waits its turn for Nawa's lock on file permissions. Before, the check held up everything else in Nawa for up to 20 seconds, and it gave up after 20 seconds even when it was only waiting for another command to finish with that lock, so the first command could fail with "The Windows execution sandbox failed its startup check." The check now runs alongside other work, and stops only if it reports nothing for 20 seconds.
• When coding ends, Nawa now reports its workspace cleaned up only once the language servers that code intelligence started have closed. Each runs in Nawa's sandbox, which, after the server exits, restores the access labels it gave the workspace, and waits its turn while another Nawa command does the same. Nawa reported the cleanup finished about 2 seconds after asking the servers to stop, while the sandbox could hold the workspace folder for up to 13 seconds more, so removing the folder right away, as deleting a chat does, could fail. A language server still starting when coding ended was not stopped at all. Nawa also now stops a command whose sandbox stalled before it could receive the request to stop; before, the request was lost and the command kept running.
• When the coder asks where a symbol is declared, where it is used, what implements it or what calls what, places outside the project folder now appear in the answer, after the project's own, with their full path and position and marked as outside the project; a place the language server names by something other than a file keeps that name. Before, Nawa left them out without saying so: Math.max, declared in the TypeScript library Nawa uses, had no definition at all, its uses were listed without its declaration, and a function's calls to it were missing. The coder still reads such a file only as its permissions allow for files outside the project.
• Code intelligence in a JavaScript project no longer tries to download type definitions for the packages the project uses. Language servers in Nawa have no network access, so every attempt failed. Opening a JavaScript project started npm, and so could an edit that imported another package; each attempt left an error log in the project's .nawa\cache\npm folder, and on a computer where TypeScript had never downloaded type definitions, the downloader crashed at once. Where Visual Studio Code had already downloaded a package's type definitions into your user folder, the language server used them without saying so, so the same project could show different types and errors on another computer. Type information now comes from the project itself, such as a package's own types or an @types package installed in it. An existing installation gets this too when Nawa starts, unless you changed the TypeScript language server's settings yourself.
• When a language server does not answer in time as it starts, the coder is now told whether the server's process existed when the time ran out, and how long the wait actually lasted. Every command's result also says how long Nawa's sandbox took to create the command's process. Before, a server that the sandbox created only after the time had run out looked the same as one that ran and never answered: both ended with exit code 1223 and no output.
• A command's temporary folder no longer stays behind when Nawa closes while the command runs. Each command gets its own TEMP folder under %LOCALAPPDATA%\Nawa\Execution\Temp, and only the command's runner removed it, when the command ended; a runner ended first, as every running one is when Nawa closes, left its folder for good, with whatever the command had written there. The next command now removes the folders of runners that have ended, including those earlier versions left, and a folder a program still holds a file open in goes at a later command. A command that leaves a read-only file in its temporary folder, as a Git clone's objects are, no longer has its cleanup reported as failed although it succeeded, which also left the folder behind.
• When the assistant publishes a web app, or an automation's first test checks that a web app shows the data the automation saves, and the app's page moves on to a page from another website, what Nawa read there now reaches the assistant screened, with passages that try to direct it removed. That covers the page's text, errors and diagnostic log in the publication's check, and in a failed test the page's text and errors and what that website's server answered for the app's data, including when the failure refuses the assistant's finished answer and when it appears later in the assistant's list of automations. Nawa keeps each of those readings with the page it came from. Before, they reached the assistant unscreened.
• When the coder finishes a web app while the page open in its browser is from another website, and Nawa refuses the finish because that page's errors changed after the coder last read them, the errors Nawa quotes from the page now reach the coder screened, with passages that try to direct it removed. Nawa keeps that reading of the page as outside content, so the coder reading the refusal again gets it screened too. Before, the page's errors, title and dialog messages reached the coder unscreened. The field names Nawa lists from a saved result that came from outside, for the coder picking up interrupted work and for an agent among the assistant's earlier steps, are screened the same way.
• Outside content that Nawa passes to a model again, from a step already taken, now reaches it screened as the step's own result did, with passages that try to direct it removed. That covers the coder's recorded checks, such as the output of a command that read a public web page, when a completion is refused, when the coder's context is compacted, and when the coder in a later request inherits earlier coding work. It also covers a web researcher's findings when the assistant asks for the same research again, and what a failed or stopped reply keeps for the next one, both at the start of that reply and when the assistant looks it up. Before, those repeats reached the model unscreened, although screening had removed the passages from the original result. Saved results still keep everything as it was observed.
• A command Nawa is starting no longer stays behind when Nawa closes at that moment. Each command runs inside a Windows job object that ends it, with everything it started, when Nawa's command runner ends; but the command joined that job only after Windows had created it, suspended. When Nawa closed in between, the command stayed suspended for good: it never ran, nothing ended it, and while it remained Windows would not let its program file be replaced or deleted, or the folder holding it be moved. Commands now start inside the job.
• An open dropdown, such as the model list in Settings → LLM, keeps its rows when Nawa fills it again with the same choices, as a connection test does when it lists the models again. Before, every refill replaced all the rows: a row you were clicking at that moment was not chosen, and the row you had moved to with the arrow keys lost its highlight.
• When an agent the assistant handed work to, such as the coder, returns its result, the outside content that result repeats from the agent's own steps reaches the assistant as the agent got it: screened, with passages that try to direct it removed. That covers the error a plugin's server or a website returned for a step that failed, and the recorded checks of a public web page or of a command that read one. Before, those parts reached the assistant unscreened, including passages that screening had removed for the agent.
• When an agent the assistant hands work to fails partway, the assistant also receives what the agent did before the failure, as it does when the agent finishes: each step it ran, such as a file it read, with a way to read its result, and how many rounds it took. A web researcher that fails after choosing sources hands them over, so the assistant can read and cite them, and its text reaches the assistant screened with its sources, as a finished answer does; the pages it did not choose are discarded. Before, the assistant received only the failure and the agent's text: it could not tell which steps had run, a failed researcher's chosen sources were lost to it, and the pages the researcher had not chosen stayed in Nawa's memory for at least an hour. An agent that stops without writing anything also lists the steps it ran.
• When a reply fails, or you stop it, while the assistant is still writing its answer, the reply keeps what it had written in a closed Unverified draft card under it. Open the card to read or copy the text as the model wrote it: Nawa has not checked it as it checks an answer, so its links are not live. Before, only the assistant's next turn received that draft, and you saw only the failure. A reply that stops at the model's output limit now says Output limit reached, and one that no longer fits the model's context window says Context window full; before, they said "Model request failed … Check its settings and try again" and "Response stopped", as if the request had failed. A reply you stop no longer shows a red "Response stopped" notice when Nawa's stop request ends it before the reply itself does.
• When an agent the assistant hands work to, such as code-reviewer, fails partway, because the model's service returns an error, its response breaks off, or it answers with only its private reasoning, the assistant receives what the agent had written beside the failure. Before, only the failure arrived, together with the private reasoning of the agent's model, and the agent's text was lost. The assistant is also told which of an agent's tool calls never ran because the model's output limit cut them off. When the assistant's own response fails partway, what it had written is kept with the failure, so it has its draft when you ask it to continue; before, the draft was lost, and the next turn received the assistant's private reasoning instead.
• A reply no longer ends as soon as it starts with "I was interrupted before I could finish. Would you like me to continue?" while Nawa goes on working on it. Nawa's window checks every few seconds on a reply it has sent but not yet heard back about. When Nawa answered that check just before starting the reply, and the window read the answer only after the reply had started, the window took the reply for lost: it showed that message after 0 seconds, and the answer Nawa went on to write did not appear.
• Nawa no longer risks closing another program when it stops one of its browsers. Before, when Nawa closed with a browser open, such as the one a PDF export starts or the built-in browser the assistant uses, it stopped that browser together with every program Windows listed as started by one of the browser's processes. Windows reuses process IDs, so that could include an older, unrelated program, such as a monitoring script run from a terminal window that was later closed, and every program that one had started. The same could happen when a browser was slow to start or could not be closed normally, and then the browser kept running until Nawa closed. Nawa now stops only the browser itself, and its own processes end with it. Stopping Nawa's engine with Ctrl+C in a terminal also lets its shutdown finish.
• When Nawa cannot connect to a model for a reason that fails the same way every time, such as a certificate it cannot trust or an https:// address whose server speaks plain HTTP, it says so at once: the reply shows LLM unavailable, and a background build stops and waits for you. Before, Nawa sent the request up to four more times first, about 15 seconds, and a background build retried its session for about 25 minutes before it stopped. The model list in Settings also says why it could not connect, for example DEPTH_ZERO_SELF_SIGNED_CERT: fetch failed: self signed certificate, instead of only "fetch failed".
• A background build whose model connection drops while an answer is arriving tries the session again after a pause, as it does when the connection fails before the answer starts. Before, the build ended as failed with "Runtime error: terminated".
• When an agent the assistant hands work to, such as code-reviewer, is cut off by the model's output limit or context window, the assistant receives what the agent wrote, marked as unfinished and with the limit it stopped at. Before, if the agent's continued response came back empty or repeated itself, or the model reached its context window or paused, the assistant was told only that the agent had produced no report, and the agent's text was lost. Text an agent writes before a tool call that the output limit cuts off also stays in its answer; before, it was dropped even when the agent went on to finish.
• When the coder picks up coding work from an earlier turn that was cut off, it gets outside content the earlier coder read, such as a web page it opened in the browser, as the earlier coder got it: screened, with passages that try to direct it removed, and marked with where it came from. Before, when Nawa had not been able to save such a result, the next coder received it unscreened, including passages that screening had removed for the earlier coder.
• Nawa no longer closes other programs when it starts. Before, every start stopped each program whose command line named something in Nawa's data\jobs folder, together with the programs that one had started. So an editor, viewer or spreadsheet you had opened on a chat's file, for example with Open in Word in the drawer, closed without saving at Nawa's next start, and so did a program that a command in a chat had opened. The commands, browsers and other programs Nawa runs for its own work end with it, however it closes.
• When a command times out, Nawa stops only that command's own processes. Before, it could also stop an unrelated program, with every program that one had started, such as a monitoring script run from a terminal window that was later closed. Windows reuses process IDs, and a program keeps the ID of the program that started it after that one has exited, so when one of the command's processes drew that ID, Nawa took the older program for one of the command's: it listed it among the command's processes still running, for the assistant to stop, and stopped it itself when the turn ended. As it starts, Nawa also no longer stops a program just because it has the process ID a workspace app's preview had before Nawa last closed.
• An agent the assistant hands work to, such as the coder or code-reviewer, gets outside content from the assistant's earlier steps, such as web pages and emails, as the assistant got it: screened, with passages that try to direct it removed, and marked with where it came from. Before, some of it reached the agent unscreened, including passages that screening had removed for the assistant: the short error page of a page that failed to load, the beginning of a page that could only be partly read, other short results, and any result Nawa could not save.
• Only Nawa itself receives the token that signs its window in. Before, the window also sent it to any program listening on this computer's 127.0.0.1 address whenever it loaded something from one, such as an app in the drawer and the server behind it, or an image in an answer, and that program could use it to act as you in Nawa. Any of them could also replace the token, after which Nawa refused every request from the window until it restarted.
• The coder starts when a step before it in the same turn failed with a large result, such as a web page that answered with a long error page, and it receives that failure's facts with a way to read the whole result, as the assistant did. Before, such a failure, for example GitHub's 270 KB page for a repository that doesn't exist, made every hand-off to the coder in that turn fail with "Complete inherited coder evidence could not fit safely in the measured context budget.", and the assistant went on without the coder.
• A file tab whose file can't be opened, for example because it was deleted, shows the workspace's files with a line saying so, as it did after a restart, and Refresh opens the file once it is back. Before, if the drawer was showing another file, it kept showing that file and its Copy and Open with buttons under the missing file's tab, Refresh removed the line saying the file was missing, and Open in folder opened the other file's folder or failed.
• Nawa's window keeps working after its network service process ends and starts again, as it does after a crash or when another program ends it. Before, from then on Nawa refused every request from the window with "Authentication is required." until it was restarted, and reloading the window showed "Approve this remote device to continue." and a pairing code.
• The drawer shows the file you opened last, and each file tab keeps its own file. Before, a file that finished opening after you had moved on (to another tab, another file, Back, an image or a spreadsheet) replaced what the drawer showed and gave its name to the tab you were on, so two tabs could hold the same file; a refresh that finished after you switched tabs could bring back the previous file the same way. While a tab's file opened, the tab also took the name of the file shown before it, and kept that file for good if its own could not be opened.
• In a window wider than 1,180 pixels, the drawer opens at 52% of the window's width, up to 760 pixels, until you resize it. Before, it opened at its narrowest, 480 pixels, until you resized it.
• Nawa starts even when Windows is slow to create its window, as it can be while the desktop is sluggish. Before, if creating the window took longer than 15 seconds, Nawa said it couldn't start, with error code 0, or no window appeared at all.
• A file search gives the assistant the search command's exit code, output and errors once. Before, they appeared up to three times, so a search with 41 matches took about 3,000 tokens of the assistant's context instead of 2,300. Searches, checks and other commands Nawa starts without a shell also no longer say they ran through bash.
• A workspace's first checkpoint leaves out node_modules, __pycache__ and .venv when Nawa creates its Git repository, even if the first attempt to create it was interrupted. Before, the next attempt took that repository for one you had made: it added no .gitignore and committed those folders. A project folder whose .git is a file, as in a submodule, no longer gets git init; before, that could add a core.worktree setting to the repository the file names.
• The assistant receives every field of a result, whatever its name. Before, fields named guidance, next_action, retry_allowed, recovery_hint or citation_instruction were removed wherever they appeared, and so, in the results of agents and automations, were fields named run_id, job_id, trace_id, task_id, turn_id, call_id, intent_id or automation_run_id. Data using one of those names, such as a value read from a page the coder tested, a GitHub Actions run an agent looked up, a dataset's columns or a saved result read back later, reached the assistant without them.
• When the coder stops at a problem it cannot solve, the assistant is told which files the coder had already changed. Before, it was told that none had changed, although they were saved. The assistant also no longer receives sentences Nawa wrote, such as "Coding objective completed and verified.", in place of the coder's own words.
• An app the coder builds is delivered only once the coder has seen every error its page recorded. Before, an error thrown after the coder's last check, for example by a timer or a slow network response, went unseen and the app was delivered as verified; the same happened when the page went to another address on its own.
• Commands in a large workspace, such as one with node_modules, take seconds instead of minutes and no longer fail while the workspace's permissions are restored, and commands in other chats and automations no longer wait for them. Before, every command relabeled every file of every workspace in use, one by one, while holding a lock every command shares; with 20,000 files a command could take a minute, and one stopped during that restore could leave the workspace writable to any low-integrity program.
• A command whose helper processes close just after it, such as the Console Window Host that Windows gives every command, finishes as an ordinary command. Before, on a busy computer it could come back as still running in the background, and a coding task could fail as it started with "Workspace git initialization failed". A process that keeps running more than 1.5 seconds after its command still continues in the background.
• Links leave Nawa only as web (http, https) or email (mailto) addresses. Before, a link opened from a chat, an artifact or an app went to Windows whatever its kind, so it could start any program registered for that kind of address, such as ms-settings:. A link that would take Nawa's own window to another site opens in your browser instead.
• With Enable permissions off, every chat runs in Manual, as Settings says. Before, the composer showed Manual while turns ran at each chat's own level.
• When the engine stops while Nawa starts, the window keeps saying that Nawa couldn't start, with the error code and the log that explains it. Before, about 45 seconds later it was replaced by a page saying Nawa was still preparing.
• server.log, firstrun.log and the trace index each keep their newest 5 MB, and the 5 MB before in a .1 file. Before, they grew for as long as Nawa stayed open; only server.log was trimmed, and only when Nawa started.
• Deleting a chat, or removing a project with its chats, deletes the chat's folder under data\jobs with its workspace, evidence and caches, and stops its turns, background jobs and apps, as the delete dialog says. Project folders are never touched.
• Nawa reaches model providers through the proxy Windows is set to use, PAC scripts included, and trusts the certificates Windows trusts, so a company proxy or an antivirus that inspects HTTPS no longer breaks every request. Commands with network access get the Windows certificates for Node and any proxy set in Nawa's environment.
• Measuring a model's context limit stops as soon as the provider accepts the oversized request. Before, a provider that shortened the request instead of refusing it wrote, and could bill, a whole reply.
• A full installation over an updated one uses the runtime it brings. Before, Nawa kept using the older runtime that updates keep beside the application, and uninstalling left that folder behind. An update likewise replaces such an older runtime with the full installation's.
• An update waits for the programs Nawa started, such as commands, language servers and browsers, to close, and stops any that remain, before it replaces files. Before, one still running could make the update fail.

• The Memory tab shows Use memory and Save new memories automatically as they are saved. Before, it could show memory on while it was off, and changing one switch could turn the other back.

• The provider guide no longer says Settings opens from a gear in the sidebar; it opens from Edit → Settings… or Ctrl+,.

• The provider guide and the LLM / Image gen page say how a setup card opens: its name opens the form with Test connection and makes it the active setup, while the circle makes it active without opening it.
• The General settings page no longer says Nawa ships about ten theme templates; it names the nine the picker lists.
• Creating, customizing, restoring and deleting agents works in the installed app. Your agents are saved in your profile, in %APPDATA%\Nawa\data\agents, where updates never touch them; before, saving one failed with "ENOTDIR, not a directory".
• The composer's agent menu lists the agents you create, customize, restore or delete as soon as you type @ again; before, it kept the roster it first read until Nawa restarted. The skills menu likewise picks up skills added to or removed from the profile's skills folder. When either list fails to load, for example while the engine is starting, the menu reads it again the next time it opens instead of staying empty or showing the error for the rest of the session.

1.0.79 — 2026-09-25

Fixed

• Ordinary final answers can complete after tool use without an extra finishing request, reducing the chance of returning to an earlier task after generating an image or completing other work.
• Direct answers use the same citation, file, artifact, and automation checks as structured answers. Rejected drafts and their exact error details remain available for recovery and inspection.

1.0.78 — 2026-09-25

Changed

• Desktop Control shows normal application windows and the primary screen, filtering hidden background windows and helper overlays. Minimized application windows remain selectable.
• The plugin views and chat actions menus close each other when opened and share the same opening and closing animation.
• Composer usage details slide horizontally when expanded or collapsed.

Fixed

• Citation favicons align vertically with their labels, including the source cards below answers.
• Header controls and project action icons use consistent alignment and sizing. Plugin fields and installation controls follow the theme's focus and spacing rules.
• Settings and plugin toggles share one control style with a thumb that stays the same size in both states.
• Plugin drawer close controls remain visible, and Desktop Control uses the shared refresh icon.

1.0.77 — 2026-09-24

Changed

• Browser actions now use the main model directly. Removed the Jev browser loop, per-action decision checks and injected browser arguments; optional decision-model rankings for search results, skills and plugin discovery remain.

Fixed

• Large external results preserve their full evidence before screening the bounded delivery; later reads still screen the retrieved content. A task failure no longer retains the label of its last successful browser step.

• Large conversations save new answers without loading and re-indexing all earlier message bodies.

• Background capability checks no longer delay Send or overwrite saved thinking preferences.
• Long-running activity journals save rolling updates incrementally while preserving their retained events.
• Waiting for a background command returns when new output arrives, without waiting for a long-lived server to exit.

Changed

• Idle automation checks run less often, while active work keeps frequent status updates.
• Math rendering and HTML sanitization load from bundled files for reliable offline startup.

1.0.76 — 2026-09-23

Fixed

• Completed automation narration stays available as a collapsible activity history above the answer.
• Automation results synchronize reliably after delayed or failed refreshes, while another chat is open, and alongside concurrent chat edits.

1.0.75 — 2026-09-23

Fixed

• Context compaction preserves retrievable history, reports evidence coverage accurately, and avoids adding estimation padding to exact provider token counts.
• Follow-up instructions reach an active coding agent without interrupting its continuation.
• Coder delivery and direct publication share artifact tracking, preventing duplicate result thumbnails.
• The compaction indicator is borderless, centered internally, and aligned with action rows.
• Artifact thumbnails match citation card widths and corner radii while preserving the citation strip's original sizing.

1.0.74 — 2026-09-22

Changed

• Automation status shapes beside chat titles are twice as large, with consistent alignment while running and after completion.

1.0.73 — 2026-09-22

Fixed

• Provider selection uses circular radios without expanding settings cards. Provider logos are white on transparent backgrounds; Laya keeps its letter mark.
• Sidebar hover surfaces share consistent widths and colors. Nested projects expand without hiding subsequent folders; child entries have consistent indentation and spacing.
• Navigation and folder artwork follows the selected theme while preserving shading, with softer colors in Quiet Slate and Emerald Parchment.
• The icon lab reflects the current interface and saved icon adjustments.

1.0.72 — 2026-09-22

Fixed

• The spine's hover preview stays beside its marker when the right drawer opens or closes.
• Sidebar navigation icons are vertically centered with their labels. Open and closed project folders are slightly smaller.

1.0.71 — 2026-09-22

Fixed

• A blocker reported by a coding agent returns to the lead for recovery. Interrupted turns retain their exact failure evidence for the next prompt without replaying the entire previous tool history.
• Application previews report misplaced manifests immediately. Verification respects explicit file-scope exclusions. Python project checks exclude internal evidence and dependency folders and recheck source even when rapid edits share a cached modification timestamp.
• Fresh language-server results avoid duplicate syntax-check processes. Windows sandbox lease acquisition combines redundant scans and records lifecycle phase timings.
• Debug reports preserve full redacted text evidence for their included turns. The context indicator explains that it measures the current model request, which can change without compaction.

1.0.70 — 2026-09-22

Fixed

• Web citations now refer to original sources the agent actually read. Search listings remain available for discovery and recall without becoming citations, including in delegated research and continued conversations.
• Historical search references display readable website links and snippets in the Sources drawer, with clear labels for unopened pages and partial saved results.

1.0.69 — 2026-09-22

Fixed

• Temporary model-server failures use shared retry handling across the lead, delegated agents, screening and auxiliary requests. Completed actions are not replayed during recovery.
• If incoming-content screening is unavailable, saved output locations, file hashes, sizes and observed HTTP facts remain available. Unscreened external text stays withheld and the original result can be retrieved after recovery.
• Sidebar root highlights now align with the edges of chat-row highlights.

1.0.68 — 2026-09-21

Fixed

• Progress narration, final answers and automation results now share resource-reference checks. Missing files, unavailable citations and unpublished application previews return factual errors for correction in the same turn. Broken links are no longer silently changed to #, and invalid app references are no longer discarded.
• File-reference checks distinguish missing files, directories, access failures and wrong-chat references. Code examples remain examples, and normal progress narration still streams before tool arguments finish.

1.0.67 — 2026-09-21

Fixed

• An answer no longer disappears when the model submits its finishing signal after repeated text-only replies. Completion recovery keeps the finishing tool available, preserves the answer draft, and uses the normal answer, citation and automation checks. Resumed work retains its tools; incomplete handoffs remain bounded by the watchdog.

1.0.66 — 2026-09-21

Fixed

• Applications edited directly in a chat can be published as a fresh, verified artifact. Existing artifact links keep their saved version, and Nawa checks that the published files still match the tested files before completing the response.
• A delayed agent-menu response no longer reopens suggestions after typing has moved past a mention or the menu has been dismissed, so Enter can send the prompt normally.
• Copy and export controls appear after the completed answer when reduced motion is enabled, including answers spread across multiple work rounds.

1.0.65 — 2026-09-21

Added

• Image creation and editing with grouped server settings under LLM / Image gen, connection testing, encrypted API keys and a separate active image server. Ask naturally or select @image; edits send the referenced image to the server and preserve the original. Images are saved in the workspace and displayed as smaller, click-to-enlarge previews.

1.0.64 — 2026-09-21

Added

• Practical guides for queues, projects, files, automations, dashboards, memory, budgets, Explorer, location and backups. Tutorial outcome tests exercise converter revision and saved artifacts, and search citations. Help freshness and internal section links are checked before delivery.

• Documentation: the handbook (install, providers, first chat, first app, permissions, plugins and connectors, instructions, troubleshooting), nine explanation pages, a generated settings and workspace-tools reference, and safety-gate checks that keep them true to the code. The site ships with the build in Nawa Dark and opens from Settings → General → Documentation.

• Decision models: a Laya card beside Jev by TypeSafe under Fast decisions; a browser plugin's snapshot and action tools take intent and expect like the built-in browser tools.
• A [decisions] line at the start of each turn in the engine log saying which decision model the turn has, or why it has none.

Fixed

• Dashboard tile shapes keep their proportions across window sizes. Dragging works over embedded apps, shows the drop position, scrolls at the edges and preserves running applications.

Changed

• A browser ranking is ordered by the lexical match of the intent against element names, with the decision model's probability reported beside it.
• The lead demands its terminal tool with required where a provider refuses a named tool choice, instead of failing the turn.
• The right drawer keeps one tab per opened artifact, file, or code review.

1.0.63

Changed

• Scoped instructions: AGENTS.md at the profile, project root and nested directories, with the deepest applicable file winning.
• Ownership icons on actions in the transcript.
• Bundled Inter and IBM Plex Arabic fonts in Nawa Dark.

1.0.62

Changed

• Instruction files consolidated on AGENTS.md; NAWA.md is no longer read.

1.0.61

Changed

• Contract audit fixes: the saved default permission mode follows the setting, not the open chat; research-only rosters drop the output format field.

1.0.59

Changed

• Shared file capabilities, encoding-preserving reads and edits, compaction corrections, and coder handoff corrections. See the release note in the source tree for the verification record.