What's new in Kaeru.

Since 0.10.0 both builds closed the moment they started, before showing a window, because the main window was set up twice. Found by installing the 0.26.0 Linux build on a fresh Ubuntu machine. The Mac app was never affected.

Picking one over 200 KB with Add photos or files used to do nothing at all: no chip, no message. Now a message names the file, says it's too big to add that way, and says to drag it onto the AI panel instead, which tells Kaeru where the file is.

After moving down the list with the arrow keys and then typing a few letters to narrow it, Enter used to do nothing: nothing picked, nothing sent. A mouse resting where the list opens could do the same. Now typing puts the highlight back on the top row, and Enter picks the row that is highlighted.

Stopping before the first word of the answer used to leave the question on its own, with nothing to say what happened and no way to ask again except typing it out.

When Kaeru tried to change a file and failed, its row in the reply said "failed" but wouldn't open, so there was no way to see what went wrong. Now it opens, and says in plain words that Kaeru couldn't find the words it meant to change and that nothing was changed, with the exact message under it.

It used to say "Something unexpected happened", with "Finished in 2s" under the half-finished answer as if it had finished. That line is gone from an answer that ended in a problem.

When Kaeru finishes a change on a work branch, it saves the files it changed under a name in plain words ("Darker header so the text is easier to read"), and the reply says so under the files it edited. There is no button to press and nothing is sent anywhere. To take it back, tell Kaeru "undo that". On the project's main branch it still asks where the change should go first. A file you had already changed yourself before asking is left unsaved for you, so your own edits never end up saved under Kaeru's name. Settings › Models › "Save Kaeru's changes for you" turns it off.

A small change like "make the header green" goes to Lite, something broken or a change across several pages goes to Performance, and anything unclear is asked of Jev, Kaeru's quick decision model, then stays on Auto if Jev isn't sure. If a request keeps failing partway through, the rest of it moves up to Performance by itself. Within a chat it only ever steps up, never back down. The speed button says what it picked and why ("Auto · Performance"). Picking Lite or Performance yourself still wins every time.

Settings › Your own AI › Other AI services takes any service that works like OpenAI: LM Studio on this computer, Groq online, or a server at work. Give it a name, its web address, a key only if it asks for one, and the model. Test connection checks it first and, when the service lists its models, lets you pick one from a menu. If something is wrong it says what to do in one sentence ("Kaeru couldn't reach that address. Check it's typed right, and that the service is running."), and it warns before a key would travel over a plain http:// address.

Instead of five cards and a Next button, it waits while you do each thing once: open your website's folder (skipped when one is open already), send the first ask it typed in for you, watch Kaeru work, then keep the change or take it back with Go back to here. Each step moves on by itself when you've done it, and you can still press anything in the window while it runs. The words are bigger (16px, with 18px titles), the buttons are easier to hit, and it follows Display size. "Skip tour" or Escape ends it at any step. To see it again, open Settings › General › Show me how Kaeru works, or find the same name in the command palette (it used to be called "Show me around").

Kaeru makes the change and saves it, instead of showing a plan to accept first, which meant pressing a button on code most people can't read. Everyday commands (starting the preview, running tests, installing what the project already uses) go ahead on their own. Kaeru still asks first before anything it can't take back: deleting, sending code to GitHub, installing something new, or touching files outside the project. If you turned on "Review AI edits before saving" in Settings › Models, nothing changes for you.

Other people see these the moment they happen. For the ones that can be taken back (sending for review, adding a task, asking someone to look, replying on a review), the card has "Always allow this", so you only answer once. You can take that back in Settings › Agents. Merging and putting the site online always ask.

Click something, say what should change, and a small Kaeru sits on it while its cursor makes the change. Then the bubble says what changed, with Undo, and goes away by itself after a few seconds (not while you're reading it). Nothing is left on the page: the pins that stayed on top of your text, and the threads beside them, are gone, and the whole conversation is in the AI panel. To keep something for later, write it and choose ⋯ › Save as a task for later.

Do this (it was Start) makes a place for the issue's work as before, then puts "Do #43: " and the issue's title in the chat box, so the next step is just pressing Send. On the issue you're already working on, the card says so and Ask Kaeru to do this puts the same request in the box, and Continue does it after going back to an issue you started earlier. Nothing is sent until you press Send, and anything you had already typed in the box stays as it is. Kaeru reads the issue on GitHub before it starts, so it works from the whole description, not only the title.

It opens on a short everyday list (General, Themes, Account, AI, Voice, Memory, What Kaeru can do, About), and everything for developers is folded under Advanced (for developers). Nothing was removed: search still finds every setting, in English or Japanese, and opens Advanced when the answer is in there. Text size is a big A / small A stepper with "Back to 100%".

Kaeru now knows where the picture is on your computer, so it no longer goes looking through your Downloads folder and asking to run commands there. The copy shows on the "Edited files" card and is saved with the rest of the change, and "undo that" or Go back to here removes it, or puts back the picture it replaced. A file nobody attached still asks.

A preview that other computers on your Wi-Fi could see still asks.

The queue used to take only the words and leave the picture behind in the box, so "this one too" went out on its own and meant nothing. The queued message shows its picture, and the two go out together when its turn comes.

They were the English left in an otherwise Japanese screen.

Each time you paused, even mid-word, the editor quietly rebuilt itself: line numbers, folding, search and suggestions, all set up again. It doesn't any more. The error and warning count in the status bar also stopped redrawing on every key.

The preview used to say "Starting your preview…" until every last picture had loaded, and a site that resizes its pictures as they are asked for (Nuxt and Next.js both do) could keep it there for minutes on a page full of photos. Now the page appears straight away and the pictures fill in as they arrive, the way they do in a browser.

Each one appears after the same short pause (0.4 seconds) wherever it is: some used to appear at once and others after nearly a second, because the app drew them two different ways with six different waits. A button no longer shows two tips on top of each other. Moving along a row of buttons, the next tip still follows at once, but after you press something its tip stays away instead of jumping straight onto what just opened. The words in tips are bigger (12.5px, the size of the rest of the app's text, up from 10.5px). Icon buttons also keep their names for VoiceOver after their tip has shown.

The start screen used to keep counting for as long as the app never arrived, past 1,000 seconds in one case, with nothing to press. Now it says "Kaeru couldn't start" straight away when the app fails to load, or "Something seems stuck" after a minute, with a Try again button. If the window hadn't appeared yet, it appears.

Kaeru asks before using those, even in Just build, so text planted in a project can't use them to do something behind your back.

It looks at the header and the first rows, picks the column that reads like a list of things to do, and says so ("Kaeru picked 'Apa' as the title"); the dropdown is still yours to change. Kaeru asks TypeSafe's Jev when you have your own OpenRouter key, otherwise its own free helper, and only the header row and two rows are sent. When neither can tell, you pick, as before.

Pasting 12 or more lines (or a very long line) into the chat box puts a short marker where you pasted, "[Pasted text #1 +93 lines]", and a chip above the box; the full text is still what gets sent, and it goes with a queued message too. Click the chip to read it, or to put it back as ordinary text. Delete the marker and that paste isn't sent.

A picture works as before, a small text file in the project is attached with its contents, and anything else (a PDF from Downloads, a folder, a file outside the project) becomes a chip showing its name and size, so Kaeru knows exactly which file you mean. A path that doesn't exist stays as the text you pasted, and a file that can't be attached says so instead of disappearing.

In Assigned to you, Import tickets is now one choice in an Add menu, next to New issue: a short form with what needs doing, optional details, whether something's broken or new, and Assign to me (on by default, because only issues assigned to you show in that list). It goes to GitHub as an issue and appears in the list ready to Start. If the project has no label for that kind, the issue is still made, without one, and the message says so.

When the branch you're on has an open pull request, a bar above the box shows its number and title, the lines it adds and removes, and a CI dot: green when every check passed, red when one failed, amber while they run. Its menu counts the checks, offers to have Kaeru fix the failing ones (it sends Kaeru the pull request and the failing checks by name), and turns on GitHub's merge-when-checks-pass, or off again. × hides it for that pull request.

In Design mode, click something and a pin with your face goes on it, with a small thread beside it: say what should change and send it to Kaeru. The pin turns into Kaeru while it works, Kaeru's reply ("Kaeru · via you") lands in the thread, and a tick goes on the pin when it's done. Reply in the same thread to keep going in the same chat. Untick "Send to Kaeru" to leave a note instead; its ⋯ menu saves it as a GitHub issue. ✓ resolves a pin; the styles that were on the element are one click away.

When Kaeru changes text in a file, a cursor named "Kaeru" goes to that text in the preview and types the new words in while the file is saved, so you see the change happen, not just the page jump. A colour or layout change still gets the cursor on the element, with no typing. If the save fails, the old text comes back.

The example rows under the chat box are gone; the box types its examples out in the placeholder instead, one at a time ("Explain this site", "Is anything broken?"), and Tab puts the one showing into the box as a full request. Examples come from your project when Kaeru can tell what it is. With reduced motion on, each example shows whole and they take turns.

A plan is now a card that folds, open by its numbered steps, with what it says afterwards underneath.

When Kaeru changes something you can see (a Design Mode tweak like "make this rounder and green"), it takes a picture before and after, and the reply ends with both on one slider: drag across to wipe from the old to the new. The line starts on the part that changed, so the first look already shows the difference.

When something is clearer explored than read, Kaeru answers with a view you can play with instead of a wall of text, without you having to ask for one. A comparison lets you pick two options and a step and see them side by side, with what differs marked. A walk-through goes one step at a time with Back, Next and Play (or the arrow keys), and tabs that swap each step's code. Kaeru draws these with its own parts of the app, so nothing the AI wrote runs on your computer.

Ask Kaeru whether your change has been reviewed, merged or is live, and the reply shows the whole road at once: sent for review, reviewed, checks, merged, and live. Done steps are green, the next thing that has to happen is ringed, and anything waiting on you (changes asked for, failing checks, a clash with main) is red. When the project deploys through GitHub (Vercel, Cloudflare Pages, Netlify and the like), the last step says where it went live.

Open an empty chat and the issues assigned to you are right under the box, with their Start buttons. Ask Kaeru what to work on, or what's left, and the reply shows the same card (the issues, this branch's checklist and pictures) with a recommendation, instead of a list typed out. When a reply changes files on the main branch, "Where should this change go?" sits under its Edited files card. The Tasks tab is hidden; Settings › General › Show the Tasks tab brings it back for now, and the link from Changes still opens it.

The line above a reply's answer now reads like "Edited 2 files, ran 3 commands, read 4 files +20 −1" instead of "Worked · 9 steps": what changed comes first, a file read three times counts once, and a change still waiting for your OK says "suggested" rather than "edited". The reply then ends with an Edited files card: each file it wrote, with its lines added and removed, marked new when it made the file, and a click away from opening. It shows three and folds the rest under Show more.

The box now holds only what you type and the send button (the improve button appears once there's something to improve). Attach, voice, how much Kaeru checks in, and which model answers sit in one small row under it, as words rather than a row of icons. Talk with Kaeru moved under the small arrow next to the microphone; while a conversation is open, its stop button stays in that row.

The examples typed into the empty chat box re-drew the entire box, with its menus and buttons, 25 times a second, so selecting text in the editor and copying it lagged. They now type themselves without redrawing anything; while idle the app does about 4% of the work it did.

Chats that already have one of those titles get the right one the next time they are saved.

A step that failed and was then done another way (a wrong guess at a file, then the right one) no longer counts as failed on the work line; its own row still shows the little red mark, and only failures nothing got past are counted in red. A failed step also no longer counts as work done ("read 2 files" when one read found nothing).

While the model thinks, the Thinking fold above the work says so; the work line under it no longer repeats "Still thinking". Between steps it says "Working out the next step", and after a long wait "Still working — this is taking a while".

A browser connector's full-resolution screenshot was sent as it came and then sent again with every later message, until the AI provider refused every request. Pictures from connectors are now scaled to what a model actually looks at, pictures from earlier steps aren't sent again, and a refusal says so in plain words instead of "Something unexpected happened".

When the space under the chat changed height (the suggestions disappearing as you sent, the box shrinking), the view stopped following and a "scroll down" button appeared although you were at the bottom. It now stays at the newest line, and sending a message always brings you to the bottom. Scrolling up yourself still stops it, as before.

Turns have more space between them, a reply starts a little below the question it answers, and the last message no longer sits under the scroll button.

Some models start a thought and share no words of it; the chat drew a "Thinking" or "Thought for 12s" row with an arrow and nothing inside. A thought with no words now shows only "Thinking" while it runs and nothing once it's done.

They opened as a narrow box floating above the page, or dropped down over the suggestions; they now hang from the top edge of the box at its full width, open upward, and shrink to fit.

When the AI called a connector without something it needs (Chrome DevTools' "take snapshot" without its page number), the connector refused it and the log said "Something went wrong". Kaeru now checks what a connector requires first, so the AI is asked again before anything is sent, and the log says in plain words what was missing. A step that failed and was then retried shows as a quiet "Retried", not as a problem.

On a dev server, "Copy output" said there was nothing to copy and "Copy command and output" copied only the command; both now copy what it has printed so far and say how many lines. Long lines the terminal wrapped come back as one line, and output that has scrolled out of the terminal's history is said to be gone instead of looking empty.

After switching or creating a branch in Changes, from a ticket, or with a git command typed in the terminal, it took up to 30 seconds to change; it now follows within a moment, and Changes also catches up after "create and switch".

The "Ask Kaeru" button that appears over a selection in the editor or terminal kept its position in the app itself, so every selection redrew everything twice when you let go of the mouse and again when you clicked away. It now looks after itself.

When Kaeru answers a small choice for you (like which column of a sheet is the title) through Jev on OpenRouter, the model behind it now thinks before answering, and Kaeru cut it off mid-thought, so it never answered. It now gets room to think and a little longer to reply.

The first time someone new opens a project, a short tour walks them through Kaeru one spotlight at a time: where their projects are, where to ask (with a first request already typed in to try), where the change shows up in the Preview, and where their changes wait until they send them for review. Skip it any time; see it again from the command palette with Show me around. Afterwards, a small pulsing dot appears once beside the permission modes, the Tasks tab and the preview camera, the first time each is on screen, and explains it in a sentence.

Settings › About, the command palette, and a thumbs-down on a reply now open a feedback box inside the app. It says exactly what goes with your message (Kaeru's version, your system, which AI answered and the model) and that your chats and code never do. It goes straight to the Kaeru team, who can reply because they know it's you. Signed out, the box offers sign-in or the web form, which needs no account.

With an Anthropic, OpenAI or Ollama key saved (and for OpenRouter, always), the Model ID field suggests every model your account can use as you type. A model newer than all the suggested ones gets its own chip marked "new", so a model released after this version of Kaeru shows up without an update. If the id you saved isn't in the provider's list, a line under the field says so, which catches a typo before it becomes a failed chat. The hand-picked chips stay, and everything works as before if the list can't be fetched.

Any line can be forgotten with one press. The "Remembered about you" card in a chat now opens this screen, and its words are translated.

Tell it you've moved, switched hosting, or changed your mind, and the old line is swapped for the new one in the same place, so the next chat isn't handed two facts that contradict each other. The chat card says "Updated about you" with the old note crossed out, so you can see what Kaeru no longer believes. If the old note can't be found, the new one is simply saved, and nothing claims a correction that didn't happen.

A camera in the Preview's toolbar takes a picture of the page for the pull request: the first press on a page is the before, the next is the after, and the toast says which. The assistant does the same on its own when a change is visible, with the same caption before and after. Pictures are kept on this computer, outside the project, and show up under Pictures on the Tasks tab, where any can be removed; they go to GitHub only when the branch is sent for review, before beside after. macOS for now; Windows and Linux say so plainly rather than guessing.

When a change starts on the main branch, Kaeru now picks one answer and puts it first, with a line saying why, instead of three buttons to weigh. A small text, picture or style change goes on your list of small fixes, sent together later as one pull request; the change moves there and gets its own line on the list. Anything that changes how the app works gets a space of its own. The other choices, including noting it as a GitHub issue, are under Other options, and Not now still skips it. The choice is made by simple rules about which files changed and how much, so it costs nothing and needs no setup.

A branch can now keep a checklist, one line per small change: replace a text, swap an image, add an icon, the month's maintenance. Tick lines in the Tasks tab, or let the assistant add and tick them as it works; it ticks a line only after making the change and seeing it work. The list goes into the pull request, so a reviewer sees ten small changes as ten lines rather than a pile of files. It is kept on this computer, never in the project. In Assigned to you, tick several new issues and press Start together: they share one branch, each becomes a line on its checklist, and the pull request closes all of them when it is merged. An issue is still optional; a branch with none works the same.

A new Tasks tab lists the issues assigned to you on the project, with a one-line link to it from Changes (which keeps its room for the files you are saving), each with one button for its next step: Start makes a branch named after the issue, from the main branch, and switches to it, so your saves go there and the pull request closes the issue; Continue takes you back to one you started; Open shows the pull request already with a reviewer. It reads GitHub and this computer only, so it works on any project without adding a workflow to it or spending GitHub Actions minutes. Ideas and epics are left out, and unsaved work on another branch is never carried along.

Paste rows from Excel or Google Sheets, or choose a CSV, and each row becomes a GitHub issue. Columns are matched by name in English, Malay and Japanese (Title, Tajuk, 件名; PIC, 担当者…) and shown so a wrong guess can be corrected; the acceptance column becomes a checklist; Bug and Feature types become labels. Every row says before anything is sent whether it will be created or why not: done in the sheet, a duplicate, or already on GitHub. Each issue carries its ticket ID, so importing the same sheet next week adds only the new rows. A person is assigned only when they can be assigned on the project; any other name stays in the issue text instead of assigning a stranger.

The assistant can add a short summary, the issue's checklist, and before-and-after pictures laid side by side, so a reviewer sees what changed on screen without asking. Boxes are ticked only for what it actually did and saw working, and the list says who ticked them; the Checks section still says only what was really run. Pictures go to GitHub's own attachment storage, never anywhere else, and the approval card lists every picture by name before anything is sent, because anyone who can see the project will see them. If one fails to upload, the pull request still goes and names the missing picture.

It shows on both now.

It says three.

The OpenRouter key field no longer says the key is optional: without one, your OpenRouter model is skipped and Kaeru's own AI answers. Ollama is described as what it is in Kaeru, Ollama's cloud with an ollama.com key, instead of "Local · Cloud".

If the photo failed to load once, for example right after the laptop woke and before the wifi returned, the generated face stayed for the rest of the session. It now tries the photo again when the connection returns or you come back to the window.

When the assistant runs into the missing connection it now says the same in plain words ("Connect GitHub in Settings › Account"), not "GitHub CLI (gh) isn't installed".

The button that drafts a name for your save said "Wait for the current AI action to finish" whenever the agent was working, a leftover from when both used the same connection. They don't any more, so you can name and save what's ready while the agent carries on. The draft describes what is ticked at that moment; press it again after more changes for a new one.

Confirming a word with the input method pressed Enter, and Enter in that box submitted the issue to GitHub; the title field now waits for the word to be confirmed.

It ran the clone in one go and kept every word git said to itself until it finished, so a large project was minutes of a spinner reading "Getting vscode (1 of 1)..." with no way to tell progress from a hang. Git reports its own numbers, and they are now shown as they arrive: Looking at what's there, Packing it up, Downloading, Putting it together, Writing the files, each with git's percentage. Both places that copy a project do this, and a clone that fails still cleans up after itself.

Opening a file that is no longer there showed a red "We couldn't show this preview", which answers none of the questions that raises: deleted or moved, my doing or the app's, and is the work gone. It now names the file and says it was deleted, and when the project's history still has the last saved copy, one press restores it exactly as it was. When there is nothing to restore from, it says that instead of offering a button that cannot work.

A picture stored beside the file always worked; one linked over the web never did, because the app's image policy lists a handful of hosts and refuses everything else, and the webview gave up before it asked. Every README badge and every screenshot hosted on GitHub was a broken glyph. Kaeru now fetches them itself through its own guarded connection, which also means a picture in a private project loads (the request can carry your GitHub sign-in, and only ever to GitHub's own address), and the page being read never learns who is reading it. While it loads, and if it cannot be had at all, a short sentence says so instead of a broken glyph.

With five tabs, a narrow pane cut the last one in half and pushed the split button out of sight; they now scroll sideways (trackpad or an ordinary wheel), the chosen tab scrolls itself into view, and a soft fade shows which side has more.

Its content column was held to 640px, which left long lists and the model settings cramped beside a wide empty margin; it is 800px now.

Kaeru never passed it anything that could trigger it; the update is so the check stays clean.

With your own OpenAI or Anthropic key, an Effort row appears under the model id in Settings › Models › Advanced, in the provider's own words: low, medium, high, xhigh, max on Anthropic, plus none and minimal on OpenAI. Default leaves it to them. Kaeru's own Lite / Auto / Performance are unchanged and still describe Kaeru's service, where Kaeru picks the model too; on your key you named the model and pay the bill, so nothing is flattened into three. The row is absent for models that refuse the setting, such as claude-haiku-4-5, which would fail the request outright.

The shared schema has allowed list_directory to be called with nothing since the day the SDK started refusing the empty call, and the runner never caught up: it passed that nothing straight to the path resolver, which read a property off it and took the process down. It now means the project folder, as it does everywhere else.

Track as an issue already filed the issue and made the branch named after it, and the branch name carries the number, but nothing read it back: the request opened without a "Closes #12" line, so the issue stayed open after the merge and somebody had to close it by hand. All three ways of opening a request now say it, including the agent when it forgets to pass the number itself. A branch that was not started from an issue says nothing, and a name that is not exactly the shape this app writes is ignored, because the wrong number closes somebody else's work.

The account check caches its answer per project so the work happens once, but it was also replaying the announcement to every later reader of that answer, and there are two on the first render — so the toast always arrived in pairs. It now reports the switch to the first reader only; the ones after are told the account was already right.

"Spoken replies" and "Live call" printed the name of the option you had already chosen at the far right of the window, level with the heading and attached to nothing, while the chosen card sat highlighted right below saying the same thing. Both are gone. And every row's content column now reaches the same width, so the two groups of cards are no longer different widths purely because one section's description ran longer.

0.23.0 shipped a list that called claude-opus-5 "strongest" when claude-fable-5-1 had already passed it, and left Fable out entirely. The chips now read everyday / hardest work / routine / quickest, which does not go stale the week a model lands, and the provider's own page under the field stays the source of truth.

Adding your own OpenAI or Anthropic account left a bare text field, so you had to know that Anthropic's current id is claude-sonnet-5. The suggestions were written for 0.23.0 and never wired to the screen; they are now chips under the field, one press each, with the recommended one first. The field stays free text, because OpenAI renames ids often and OpenRouter has hundreds, and a fixed list would go stale and need a release to fix.

Settings › Models › Advanced › Add provider now lists OpenAI and Anthropic beside OpenRouter and Ollama Cloud. Paste the key, type the model id (the field suggests the current ones, such as claude-sonnet-5), and the composer's model menu offers it. Requests go through Kaeru's own guarded proxy, so a Claude key works from inside the app. The built-in Lite / Auto / Performance tiers are Kaeru's own service; your own account always uses exactly the model you named.

When a change starts on the main branch of a project that lives on GitHub, a line appears above the changed files, in the Changes tab and in the review bar: "This change is on main. Track it as an issue?" Issue + branch files the issue with a one-line title drawn from what you asked, assigns it to you, and switches to the branch named after it, so Send for review closes it later. Branch only makes a branch and touches nothing on GitHub. Not now keeps quiet for the rest of the session, and a switch in Settings › General turns the offer off. The agent is told the same habit: offer an issue before non-trivial work on main, never require one.

"Copy as Pathname" in the Finder and paste into the box, and the image is attached, the way Claude Code treats it, instead of the path sitting there as words.

"Replace the image with the one in my Downloads" used to end in a shell command you had to run yourself, because an image is binary and the edit tools cannot carry it. A copy tool now does it, always asking first with both ends named on the card, whatever mode you are in. The picture appears in the preview the moment you say yes.

Settings › Activity shows what happened in Kaeru as it happens: setups and runs, git failures, and, on top, how many problems a free rule answered against how many were handed to the agent, which is the first time that can be counted rather than believed. Filter with stream:git level:error last:1h or any word, pause the live view, copy what is shown. It records that something happened and its kind, never chat words, file contents or command output; it is capped at a few megabytes with the oldest part dropped by itself, and a switch turns it off and a button clears it.

One press used to fetch the project's packages and then wait for a second press on Run; now the app starts by itself once the install's own terminal says it finished and the folder agrees. A setup that failed used to go back to "Set up" and say nothing. Kaeru now reads the end of the output: a missing pnpm, yarn or bun is fetched with one press and setup continues; no Node.js at all opens the download page; a dropped connection offers Try again; and anything else offers Ask Kaeru to fix it, which hands the output to the agent. The usual cases are read from the project's files and cost no AI requests; only the last one does. The two Run buttons (status bar and empty preview) now share one "Setting up" state.

A dev server that died on the way up left an empty Preview and a button that quietly went back to Run. A dev server does not end by itself, so when it does, Kaeru reads what it printed: a package the project names but this computer lacks (a teammate added one, a branch changed the list) offers Set up and run; a missing pnpm, yarn or bun is fetched; and anything else, a syntax error or a bad config, offers Ask Kaeru to fix it with the output attached. It is said on the Preview's strip and in a toast. Stopping the app yourself says nothing.

It used to be a sentence, with git's own words behind a disclosure, and nothing to do next. Now: when git refuses to save because it does not know who you are (everyone's first save), Use my GitHub name sets it from your GitHub account, with GitHub's private address rather than your real one; a refused sign-in offers Sign in to GitHub; and a clash, a stuck lock, edits in the way, or a failure Kaeru does not recognise offers Ask Kaeru to fix it, which hands git's message to the agent. Failures that already had their own button keep it.

The notice used to end "a person needs to sort this out in the terminal". Bring theirs in, keep mine now tries the fix that needs no judgement: their saves come in, yours are replayed on top, and unsaved edits are set aside and put back. If the two really clash, Kaeru undoes the attempt before telling you, so you are never left half-way, and the button becomes Ask Kaeru to fix it, which works through each clash with you.

GitHub's refusal ("a pull request already exists") was shown as a failure; the link inside it is the thing you were after, so Kaeru opens that request's card instead.

An error in the page after an edit showed an empty white preview and no sentence, because the preview is a separate site the app cannot look inside. The small script Kaeru already puts in every previewed page now reports uncaught errors, and the Preview shows the message with one button: Reload the page when the page only lost one of its own pieces (a restarted server, a stale hot update), or Ask Kaeru to fix it for a real mistake, with the message and where it happened attached. Only the error text leaves the page, never its data.

The card said "2 checks are failing" and offered nothing. Find out why looks at which jobs failed: when it is only the tidy-up kind (lint, format) and the project has its own script that fixes those, Kaeru runs that script, no AI involved; otherwise it hands the agent the job names and the end of the failed log, to fix it and tell you what was wrong, without pushing until you say so.

Looking at an older point in the project showed a grey "No branch" chip and nothing else, while a save made there belongs to no branch and can be lost. The Changes tab now says so, with Keep this on a new branch (always safe: it moves nothing) and, when nothing is unsaved, Go back to main.

It showed git's own paragraph in a toast that left in seconds. Now: if the folder is already there (you got it before), Open it; if the internet dropped, Try again; if GitHub refused or hid the project, Sign in to GitHub; and anything else, Ask Kaeru, with git's message attached. The toast stays for half a minute.

Ask Kaeru was the only way out of a failed command, and it is an AI turn every time, including for "command not found: pnpm", which has one answer. When the output already names the fix, a button beside Ask Kaeru does it and runs your command again: Get pnpm (or yarn, or bun), Set up and run when a package is missing, or Get Node.js. Everything else still goes to Ask Kaeru.

The branch named on the Send for review card ("…that main doesn't have yet") is now a small chooser, the same one GitHub's compare page has: the project's main branch is first and already chosen, and a team that reviews into develop or staging picks it there. The count of saves follows the choice, and so does the request.

A picture, a font, a video, a lockfile or a Finder leftover is noted by rule ("new picture", "exact versions of the building blocks, updated by setup") and never sent to the AI; a change-set of only those costs nothing. For the rest, the AI is now sent just the parts of the diff for the files it is asked about, so a lockfile's thousands of lines no longer push the real files out of view.

The grey suggestion in the box and the chips above it each asked the AI about the same reply, a moment apart. They share one request now; the box takes the likeliest suggestion and the chips take the next two, so they never repeat each other.

The grey suggestion that appears as you type is the one AI request nobody presses a button for, and it fired on every pause. It now waits whenever the language server's own list is open or on its way (real names from your project, free), and whenever there is code to the right of the cursor, where a suggestion almost never fits. It is still on by default and still appears at the end of a line. How often the free answer won is counted in Settings › Activity.

It cannot (signing up needs your own email, a password only you should know, and a human check), so it says so in a sentence and points to the free sign-up and to Connect GitHub, which signs Kaeru in with a one-time code. It never asks for a GitHub password and never sends anyone to a terminal for it.

It opened Settings › Models, where there is nothing to connect; it now opens Settings › Account, where the GitHub card is. Two leftover sentences telling people to "open a terminal and run gh auth login" were removed from the catalogue; nothing showed them any more, and nothing should.

The editor sat at a fixed 13px beside an 11px terminal and 11-12px text everywhere else, and no setting reached it. It now follows the terminal's font size (Settings › Terminal › Font size, 11 by default), so the two mono surfaces share one typeface and one size, and one slider moves both.

Git's own .git folder stays out either way (the Changes tab is its window), as does .DS_Store.

Its own folder listing dropped every dot-entry, so it could not tell that a project had a .git folder, an .env or a .github, and said so. It now lists the folder as it is; what it may read is still governed by the secret-path deny-list.

The size every menu row uses (text-menu, 11px) was set on the shared menu components but could be overridden per row, and thirty-three rows had been: the model picker at 14px, the project menu and script menu at 12px. The shared components now have the last word, so a row cannot be made larger by accident again, and the overrides are gone. Rows follow the display-size zoom like everything else.

It was positioned in real pixels and then zoomed, so at 130% it opened a third of the way across the screen from the chip, and at 90% short of it. Positioning and zooming are now separate boxes.

Retry kept the old reply aside and put it back when the new run "produced nothing", but it looked for the old reply by an id the new run never reuses, so it always read as nothing and the old reply was appended after the new one: two replies in a row, and an approval card in the first that could never resume, which is why Allow once did nothing. Retry judges the replacement now, and a run paused on a card counts as having answered.

A reply that failed showed "Stopped · Retry" on its own line and then the failure card with Try again under it: two buttons for the same thing, and "Stopped" for a turn nobody stopped. The card owns the retry now.

It only worked when a terminal tab was in front; with the preview open it silently did nothing. It now opens the bottom terminal and pastes the command there, or copies it and says so when there is no terminal at all.

Set up was only offered when the top folder had scripts, so a root that is just a list of packages skipped it and offered a Run that failed on its first line. One setup at the top covers every app inside, and Run then starts the likeliest one.

It measured the branch against this computer's copy of main, which is only as fresh as the last time you stood on main and pulled: a branch GitHub showed as 33 commits read as "384 saves that main doesn't have", and the request's description would have listed the other 351 as yours. It now measures against GitHub's copy of the base branch, and falls back to the local one only for a project with no remote.

The hint under a button was set larger than the labels around it; both tooltip styles now use the same small text and tighter padding.

View, open and undo appeared only when the pointer rested on the row, so most people never saw them; they sit beside the counts now, quiet until hovered, but there.

Under the allowance in Settings › Usage, when signed in: type the code, press Redeem, and the extra requests land on the same meters the card shows. Each refusal says what it is: not a code Kaeru knows, expired, used up, already redeemed, or too many tries today. Until now a code meant finding the website and signing in there.

Two new chips in the row above the box, each one press: Fix what failed when a step in the last turn failed, named on hover, which sends "the step X failed, work out why and fix it, then carry on"; and What did the team change? after the team's saves came in on their own, which asks Kaeru to read exactly those saves and say in plain words what changed and what to know before continuing. Like the rest of the row, neither shows while Kaeru is working, and each disappears once it is answered.

Someone with no GitHub account and no developer tools used to hit "ask whoever set this up to install it". Now the Changes tab and Settings › Account offer Connect GitHub: a link to create the free account if they have none, then Kaeru fetches GitHub's helper itself when the computer has none (GitHub's own release, checked against GitHub's published checksums, kept in Kaeru's data folder and never over anything they installed), then the sign-in: GitHub opens in the browser asking for a code, and the code is shown large in Kaeru with Copy. When GitHub approves, Kaeru says who is connected, and backing up and Send for review work from then on. No terminal, and no password ever passes through Kaeru.

Until now a skill only ran when you chose it in the box; the agent was never told what was installed, so it reinvented flows that a pack already described. It now sees a list of installed skills and commands, name and one line each, and loads the one that matches what you asked before starting the work. The step shows in the run as "Use a skill" with the name, so you can see it happen. Typing the slash still works and still wins.

Kaeru already fetched every few minutes; now, when people you work with have saved to GitHub and nothing of yours would be overwritten, it brings their saves in and says so: "Brought in 3 saves from the team". It waits when you have unsaved edits, saves the team does not have yet, or Kaeru is mid-edit, and the reason sits on the button next to the count. When your own pull request merges while you are still on its branch, Kaeru puts you back on the main branch, up to date, and says your change is in. A brought-in save shows in the preview and the editor at once. Off with one switch in Settings › General.

"Note this down", "make a ticket for the broken image", "start a change for the about page": the agent opens an issue on the project's GitHub, assigned to you, and can start the branch for it on this computer with the team's own name, i135-20260917-1505. It asks first, like a pull request does. When the change is ready, Send for review from the agent can name the issue and the pull request closes it on merge. Pull requests you open are now assigned to you as well, except ones sent from a copy of somebody else's project, where assigning is not allowed.

A public repository is public to read, not to write, so a teammate who was never added to it used to hit "your account isn't allowed to write to it" and stop there. Kaeru now asks GitHub up front whether the account may write, and when it may not, the Saved screen and the unsent-saves card say "You can't write to {owner}'s project, but you can send your saves as a suggestion" instead of offering Send to GitHub. One press, after a yes: Kaeru makes a copy of the project on the person's own GitHub, sends the saves there, and opens a pull request to the owner with their name in it, so GitHub notifies them. The owner approves it from Kaeru's pull request card or on GitHub, and nothing in their project changes until they do. The copy is reached over https with the signed-in account, never with whatever SSH key the computer happens to hold. Later sends from the same branch go to the copy on their own.

In Plan first, a second change to a file Kaeru had already changed was worked out from the untouched disk, not from its own first change, so the queue showed the same file twice, Keep all landed the first and refused the second as "changed since proposed", and Keep anyway on it threw the first away. Now one file has one row: a later change builds on the earlier one and replaces its row, Kaeru reads its own queued version of a file when it looks again, and the "changed since proposed" notice carries a Keep all anyway for the times something really did move.

Older replies hid Copy, Retry and the thumbs until you hovered, and showed icons only; the newest spelled them out. The newest reply's version is the only one now: small, labelled, always there. A thumb you pressed turns green and nothing else.

When a run finished, the whole queue used to leave at once, two bubbles back to back, because the next message was sent the instant the panel read as idle, and when a run pauses on an approval card there is one frame where it reads as idle. The queue now waits for idle to hold, re-checks before sending, and sends one message per run. The dock reads "2 Queued · drag to reorder" as the reference does, with the run-next arrow on every row.

The stream pauses on an approval card, and that pause read as idle, so a message typed then was sent straight into a run that could not take it: two bubbles with no reply, and nothing in the queue where you were looking. It queues now, above the composer, and runs once the card is answered. The footer under the paused turn says "Waiting for your OK" instead of "Stopped", since nothing stopped. Editing a queued message happens in the composer, under an "Editing queued message" strip with Cancel, the way the design reference shows it, and the queue rows carry the reference's grip, empty ring and hover actions.

The app keeps selection off for its own chrome, and the diff never turned it back on, so dragging across a line did nothing. Lines select now, the line numbers stay out of the selection, and each side has a Copy button that takes the whole of that side, because a two-column comparison selects both columns at once and never gave clean text anyway.

The screen said "Start your app" and offered no way to, since Run lives in the status bar; the same Run pill sits on the screen now, with everything it knows (install first, static folder, monorepo picker). Retry now is what it always was, a check of whether something is answering at the address, and says so on hover; it rests for a few seconds after a press instead of taking ten in a row.

With two GitHub accounts signed in, every read and push ran as whichever was active last, so a company's private project answered "That project is not there, or this account cannot see it" whenever the personal account happened to be active. Kaeru now asks GitHub which of the signed-in accounts can see the project, switches to it once per folder, and says so. The old guess matched the remote's owner against the logins, which could not know that a company's repository belongs to your work account.

The agent has a read-only view of the saves a branch has that main does not, with who made them, when, and the files they touched, so it can answer in Plan first mode instead of asking you to paste terminal output into the chat.

Resting on a button used to bring up the operating system's tooltip: a second late, drawn wherever macOS felt like putting it, often nowhere near the button, and looking like nothing else on the screen. Every button's hint now appears under the button itself after a short pause, follows you from button to button without waiting again, shows on keyboard focus, and goes with Escape or a press. Icon buttons that only had a label for screen readers show it too. Nothing had to be rewritten: one layer at the window takes over every hint the app already had, in both the main window and Settings.

Its file search and glob skipped every hidden entry, so .github/workflows, .env.example and the like were reported as not existing; only the repository's own .git store is skipped now, and .gitignore rules still apply. The Files tab has its own switch for this under Settings › General › Show hidden files.

Both tags are stripped now, and the command shows as the same quiet inline mention a skill does, followed by what you typed. Chats already on disk read correctly too, since this happens when the bubble is drawn.

The Enter that confirms a kana-to-kanji conversion was taken as "send" by the chat, the edit box, the reply box, searches and renames, so a Japanese person could not finish a word without firing the message. One guard at the window now stops the confirming Enter before any box hears it, on every browser's spelling of it, including Safari's late one.

GitHub's "Permission to owner/repo denied" and its bare 403 matched nothing, so someone trying a project they were never added to got "Something went wrong". It now says the account cannot write to this project, and what to do: ask the owner to add you, or work on your own copy.

A save empties the Changes list, and if the send after it was refused, all that remained was "Nothing has changed yet" and a toast already gone, which read as the work having vanished. A card now says "2 saves are on this computer, not on GitHub yet. They are safe here." with Send to GitHub and the reason the last send was refused, and it stays until one succeeds.

The old name assumed the person on the other end is a developer; a pull request is just as useful sent to a teammate, or to yourself to look at later on your own project. The hint says so, and nothing about what the button does has changed.

Save on a side branch, back it up, and the Changes tab used to read "Nothing has changed yet" — true of the files, wrong about the situation, while GitHub's own page was offering the pull request. A card now sits where the pull request card will: "{branch} has 2 saves that main doesn't have yet" with Send to your developer, and it steps aside the moment a request exists.

Typing a name always offered "Start a new branch: name", but a list of existing branches never said so; a standing "Start a new branch…" row now sits at the bottom, and pressing it asks for the name. The new branch is made on this computer and switched to; nothing goes online until you back up. The tabs under the search box also got room to breathe.

After it had been on once, clicking through to another page and switching it on there did nothing: the pane remembered the first page's "ready" and skipped the reload that puts the script into the new page. It now asks the page actually on screen whether the script is there, and reloads only when it is not.

The tab was restored before its folder's server was revived, so the pane's one question "which folder is on this port" came back empty and was never asked again; the reload listener stayed dead for the tab's whole life, and an edit made after that showed only on a manual reload. It asks once the server is up. When the in-page reload is not available, the fallback now reloads where you are instead of the first address.

A new chat took its project from the terminal's or the file tree's folder, and a window showing only a Preview has neither, so every chat started there filed itself under "Other chats" while the project read "Nothing here yet". A new chat now takes the project you have open; a chat that was born without one adopts the project it is used in the first time it has anything in it; and the launch-time pass that works out a chat's project from its transcript now waits for the projects list instead of running against an empty one.

The Lite tier's model cannot take an image, and the built-in service answered such a turn with "No endpoints found that support image input" — on the one turn where the person had attached a screenshot. Kaeru's service now looks before it routes and sends an image turn to the tier that sees, billed as the tier you chose. With your own key on a model that cannot see, the sentence says so plainly instead of quoting the error.

Guarding new attachments was not enough: the image part was still on disk in the message, and every edit, retry or next turn sent it again and failed the same way. Such parts are now mended from the file's name, or left out, at the point where the conversation is prepared for the model.

An edit used to re-send text alone, so editing one word dropped the screenshot the question was about, and there was no way to add one.

The image's type crossed from Rust under one field name and was read under another, so every such image went out as data:undefined, the request failed its own schema, and the chat said it had lost track of the conversation. The field is named the same on both sides now, the file name is the fallback, and an image with no type is left out rather than taking the turn with it.

The small model behind them sometimes answered instead of speaking as you, and one Tab put "I'd be happy to explain, but I don't see any project attached…" into the box; a suggestion that reads like a reply is now dropped.

A blocked chat that belonged to no project was counted but not listed under the filter, which answered with nothing; Other chats now stays, cut to what needs you.

It remounted the frame at the address it was first opened on, so from About it went back to Home.

A mermaid block in a rendered Markdown file or in a chat reply becomes the diagram it describes: flowcharts and data-flow diagrams, sequence and state diagrams, entity-relationship, Gantt, pie, mindmaps, timelines. It follows the app's light or dark theme, keeps the copy button for the text, and a diagram that cannot be drawn shows its text under one line saying so. Rest the pointer on one for its controls: zoom in and out, actual size, open large. A click opens it large, the way a README's diagram does on GitHub, where the wheel zooms, dragging moves it, and Escape closes it; in the page, Cmd or Ctrl with the wheel zooms so ordinary scrolling is untouched. The drawing library loads the first time a diagram is on screen, never at startup.

Merge, Send to your developer, Fix the clash, removing a project from the sidebar, removing a provider or a pasted key, deleting a theme or the downloaded speech model, removing a connector or the wallpaper, signing out, forgetting the usage numbers, and closing a split pane with something still running: each gets one short question in the app's own dialog, saying what happens and what stays, with the deed as the second button. Things that already asked, had a second press, or could be undone are unchanged. The one place that used the operating system's own prompt (removing a project) now uses the same dialog as everything else, and asks every time rather than only when a tab was busy.

It follows the change: "went into main" once merged, "did not go into main" if closed.

Buttons doing the work keep their spinner.

When Kaeru says it has asked the agent to look, a line under the face now shows the step it is on — the same "Reading index.html" the chat shows — with a small pulse, and it clears when the agent finishes. Saying "approve" on a call now also keeps changes waiting in the review bar, not only tool approvals, and Kaeru tells you when changes are waiting there; "no" undoes them.

While you talk, the frog leans in and grows a touch with your voice, a soft ring behind it swells with how loud you are, and its eyes open when you speak up — all from your microphone, through the same smoothing the eyes already had but the face was not using. At rest it breathes slowly instead of sitting still. Nothing moves while Kaeru itself is talking, so the two never fight.

Settings › Models › Live call chooses the engine: Kaeru built-in (as before, on the voice minutes) or ElevenLabs Agents on the key under Spoken replies, with their turn-taking and the voice you picked, on their bill and none of Kaeru's minutes. Kaeru still does the work: the call only talks, and hands requests to the same agent through the same tools. The first call creates an agent named "Kaeru" on your ElevenLabs account and reuses it after that.

Settings › Models › Spoken replies chooses who reads a Talk mode reply aloud: Kaeru built-in (on the voice allowance, as before), or your ElevenLabs or Fish Audio account on a key you paste there. The key is kept in the OS keychain beside your AI keys and never passes through Kaeru; the voice picker lists what the key unlocks, Preview plays a sample sentence, and if the vendor refuses a request the built-in voice reads the reply so Talk mode never goes silent. The live call has its own choice, one row down.

"Write it for me" drafts the note to your reviewer from the steps you saved on the branch — two plain sentences in the app's language, in the box for you to change before Send. And when the change clashes with newer work on the main branch, "Fix the clash" hands it to Kaeru: bring main in, settle the clash keeping both sides where it makes sense, check the site, push. Until now that sentence had no button under it, and a clash is the one state a person cannot fix on GitHub without reading code.

The server dies with the app, so a restored tab pointed at nothing and "Retry now" only looked again. The pane now asks the app to start the folder's server when one of Kaeru's own ports is down, on the first miss and on Retry, and the next look finds it up.

Once a change is sent, a card on the Saved screen (and a strip above the Changes list) says in one sentence where it stands — waiting for someone to look, approved and ready to merge, changes asked for, a failed check — with who is involved, what they said on the change, a box to answer them, "Ask for a look" with the people who have access, and Merge when it's allowed. "Send to your developer" no longer opens the browser; the link is on the card for anyone who wants github.com.

Each of the three writes asks first, since they act on somebody else's repository.

Kaeru's own abilities are one list, always on and named so; packs are their own cards, each saying what it brought — "Adds Audit links, Compress images, Sitemap and 1 more · 1 connector" — with where it came from, a switch, and a plain "Not working" when it is broken. The two packs that ship with Kaeru are named Content editing and GitHub workflow, as the technical view already called them, instead of "a pack you added". Under the hood, three phantom packs called ".git" are gone: Claude Code leaves abandoned marketplace clones in its plugin cache, and Kaeru was walking their .git folders as if they were installed plugins. Discovery now skips dot-folders and stray clones and requires a plugin manifest.

Wherever the app fetched something behind a spinner or a "Loading…" line, or showed nothing at all, it now draws a placeholder in the shape of the thing coming — rows for a list, lines for a file, a card for a card — with a slow, faint sweep instead of a pulse, and none at all when the system asks for reduced motion. Covered: the chat column while sessions and keys load, the file tree, an opening file, the project menu's lists and search, the pull request card, the source-control panel and its branch list, an inline diff, git history, the usage meters in the popover and in Settings › Usage, and the Models, Skills and Add-ons settings. Buttons doing work keep their spinner; that is progress, not layout.

The menu no longer swaps itself out for the list, so the recents and the other choices stay in view. Moving to another row closes the panel; clicking a row opens it and puts the cursor in its search.

A file opens its folder as the project and then the file itself. Windows and Linux get the same through file associations. Kaeru is offered, never made the default app for a type.

The rest of the guide, the README and the planning files (roadmap, TODO, FOCUS, PRODUCT, KAERU.md) were walked against the app and corrected: the Settings section is "Models", the voice rows are "Spoken replies" and "Live call", the review loop after a push is described where it lives, and things that shipped in September are no longer listed as planned or as things we are not doing.

0.16.0 and 0.17.0 are on the public repo now, with plain-language notes.

The updater manifest script knows the _universal name and lists it under every darwin key, and the mirror script accepts a manifest that already points at the public repo and refuses one with private API URLs. The runbook has the CI path that shipped 0.18.0.

They say "Settings › Models › Spoken replies" now, in both languages.

The reason a turn stopped is now remembered with the turn, so a reload no longer shows "Stopped · Retry" with the sentence gone.

It counted commits against the branch's own upstream, which is zero the moment the branch is pushed; it asks git for the commits ahead of the base branch now.

It only ever happened after a hot reload in development, when the composer module re-ran and made a new context object that its already-mounted consumers were not reading; the contexts now live in their own module, which a reload of the composer does not re-run.

Nothing ever opened the files the agent wrote — the review diff closed itself the moment a change was applied, and in "Just build" mode there was no diff at all — so after "make a landing page" the Editor had nothing to show, which read as the editor being broken. Every file the agent writes inside the project now opens as an editor tab quietly, without taking focus from the chat or the preview, so the code is there when you look. The Editor's empty state also says so, instead of sending you to the Files tab.

It hangs off the control you pressed, and with no control to hang off it sits centred near the top of the window.

The request for your repositories was being marked stale the moment it started, so its answer was thrown away when it arrived a second later.

That covers the dropdown, context, command, select and menubar primitives, and the hand-built ones: the project menu and its flyouts, the project row menu, the bell, the file and folder pickers, and site actions. The primitives also share the dropdown's radius, padding and icon size now, where four of them still had shadcn's larger defaults. The size is a single token (text-menu), so the next menu gets it by name instead of by guess.

The folder chip is the one that gives way now, shortening its path, and the row clips what still does not fit.

A size you already chose is kept.

Both used to follow the Command blocks setting, so with it on (the default) the item named Terminal quietly opened a Blocks tab. The setting still decides the kind for terminals Kaeru opens on its own.

Renaming a tab still wins.

It still never travels in the link — typing or pasting it on the page is what proves the page and the app are in the same hands — but it no longer has to be typed by eye.

One search over everything; Recent; On this Mac and On GitHub side by side, each with Select multiple to open or get several at once; Start something new; Choose a folder; From a link. Getting a project from GitHub is a click — Kaeru copies it to this Mac and opens it — and never a terminal.

The first file opens by itself; each card carries the plain-language note.

The row stays, greyed out and struck through, saying "put back the way it was", and the same arrow puts the edits back. Nothing is thrown away: the edits wait on git's stash, so they survive a restart, and a file that was never saved comes back too. The only irreversible action left is "Throw away all changes" under Advanced, still behind its dialog.

The pane re-checked "is the server up" on every address change and unmounted the frame while it asked; it now checks per server.

In place, so you stay on the page you were on.

Opening the download now shows Kaeru's faces around the two icons and an arrow that says what to do: drag Kaeru into Applications. The app runs on Apple silicon and Intel Macs from this release, in one download.

While you are signed in, every running chat is mirrored to the phone as it happens: what Kaeru is doing, in sentences; an approval or a question it is waiting on, answerable from there; a follow-up typed on the phone lands in the same chat, marked "From your phone". Settings > Account > Show my sessions on my phone turns it off.

When the model hasn't started answering within 90 seconds, Kaeru says so and suggests Lite, instead of "The AI service is having trouble".

It said "Auto" whatever you chose.

When the AI asks for a listing without naming a folder, it gets the project folder instead of an "invalid input" error.

The Working card says "1 step failed" beside the count instead of turning the whole card red.

Mapping a project used to be hundreds of tiny reads; it is a single read now.

The rule that keeps Kaeru's AI out of .env files, keys and credential folders now runs inside the file commands themselves, not only before them.

Each conversation's transcript is kept in its own file now; older ones move over the first time they are opened.

A conversation shows its last sixty messages; earlier ones wait behind one line, "N earlier messages · Show them", instead of every message being drawn and redrawn on each token.

A keystroke no longer re-renders the whole panel and transcript; a streaming answer repaints at most every 60 ms instead of once per token; the usage ring stops re-counting the whole conversation on every token. The Stop button now reaches a running helper or expert panel. Every tool has a plain name on the Working card ("Map the project", not "project_map").

Every file and search command ran on the window's own thread; they run beside it now. A search also skips dependency folders and gives up after ten seconds instead of walking a whole node_modules.

A build's output is compressed and trimmed before the model sees it, so one pnpm build no longer ends the chat with "too long". Listing a folder stops at 200 entries; the project map reads only the top of each file.

If nothing comes back for two minutes while no command is running, Kaeru stops the turn and says it took too long, instead of sitting on "Working · Thinking" until you press Stop. After 45 seconds the card says "Still thinking — this is taking a while" so a slow model and a dead one no longer look the same.

Since 28 August an approved command in "Ask me first" was never actually executed: Kaeru told the model the step had stopped, the model asked again, then gave up, and the row sat on "responded". Approving runs it now.

The model's thoughts are one folded "Thought for 3s" line above the Working card; the card is the steps alone; the answer follows. Thinking → working → answer.

A server that ignored the tab's hang-up used to outlive it, and the next Run found the port taken with nothing to show for it.

Each site gets its own proxy; a click in one tab no longer moves the other's address bar; and a dev server that dies is reported at once, not after the WebView's own error page has sat there for ten seconds.

Turning the microphone off no longer counts as leaving.

Ask Kaeru instead".

Settings > Account now says which workspace you are in, what you are in it (owner, admin, maintainer or member) and what that lets you do: merge and publish, ask for a review, or look. If you are in a team without a paid seat it says so, and whether you have already asked for one.

Off until you turn it on, per machine, with a marker in the status bar while it is listening and a way from there to the switch. Turning it off stops a task already running, not just the next one.

Settings > AI takes a list of other folders for the project you have open, so you can say "update the changelog in the website folder" without switching projects. Kaeru is told the list on every turn. Adding one uses the app's own folder picker, search and all, not a system dialog.

Press the mic, say what you want, let go. What you said is sent as a message, the ordinary agent does the work, and the start of the reply is read aloud. The transcriber is told your Call language and the names it is likely to hear (the open files, the project), so ".env.example" comes out as ".env.example". On by default; Settings > AI > Talk mode turns it off, and dictation then only fills the box. The live call stays for conversation.

The moment the agent clicks or types in the previewed page, the Preview tab comes forward and a strip across the top says "Kaeru is working on this page" with a Stop, for as long as that run lasts. The glowing cursor already showed where it was about to touch; now you are looking at it when it does. Only page actions bring the tab forward: a saved file reaches the page through hot reload and must not pull you away from the code you are reading.

Kaeru reports the folder it has open to your account and, every few seconds, asks whether a task is waiting for it. A claimed task runs through the normal chat in a new session (Just build tasks with the build permission mode, so nothing waits on a keyboard nobody is at) and reports how it ended in sentences. A stop from the phone stops the chat and keeps what was finished.

While a task runs, every edit and every command becomes a sentence on the phone as it happens ("Editing styles.css", "Running: install packages"); reads collapse into one "Looking through your project." The summary lists the files touched.

When a task finishes and a dev server is running in that folder, the Mac puts it on a temporary public address the same way the Share button does (a quick tunnel through Kaeru's preview proxy, no project config touched) and sends the link with the summary. Live while Kaeru stays open.

Settings > AI > Call language says what Kaeru Voice listens for and answers in. "Same as the app" is the default; pick Malay, English or Japanese when you speak to it in a language the app is not in. With the app in English and the person speaking Malay, the transcriber turned ".env.example" into three other languages in one call.

After a Back up, a notice names what was saved and offers "See this save", which opens the commit on GitHub, so the person who cannot read git output has something to look at and send to someone.

Thin bars beside the line numbers: green for a new line, amber for a changed one, a small red wedge where lines were removed, all against the last save to git. They follow every keystroke, and clear when the file is saved to git.

Rest the caret on a line and a dim caption appears after it: "You, yesterday · feat(staging): GTM off". A line git has not seen yet says so. Hover the caption for the full commit. Current line only, on purpose.

The editor refused to reload while you had unsaved edits, which is right, and then saved over whatever had arrived on disk meanwhile, which is not. An edit from Kaeru, a branch switch or a second window could vanish, and clicking away was enough to trigger it. Now the editor says the file changed on disk and lets you reload or keep yours.

Any failed reply from the account service reported the free plan with fifty requests. The last good answer is kept and used instead, while a genuinely refused sign-in still clears it.

Files git had never saved were removed with git clean, which cannot be undone; in a folder set up a minute earlier that was every file in it. Such files now go to the Trash, and the confirmation says which edits cannot come back and which can.

Kaeru wrote a .env.example into a project whose .gitignore has .env*, the Changes tab stayed empty, and nothing said why. The editor now shows a line above such a file, and Kaeru un-ignores a template it creates instead of leaving it stranded.

One failed profile fetch at launch (the account server mid-deploy, a lid just opened) used to leave that placeholder in the sidebar for the whole session, with Free shown to somebody on a paid plan. The app now asks again a few times over the first minute, and once more whenever the window comes back while the placeholder is still up.

A dev server that died on a taken port can echo the address it wanted, and the Preview used to open it: somebody else's site, with no sign it was not yours. The port is checked before the Preview opens, and the Preview says in a sentence what happened: "Something else is using port 3000, so your site started on port 3001 instead", or that it could not start and what to do, or that the printed address does not answer.

It loads lazily now, and the startup-bundle test is green.

Turn detection waited so long for a finished thought that every reply arrived a beat late; it now answers when the sentence is plainly over. And a clear request goes to the agent straight away instead of being read back for confirmation first.

It used to read the file once on open and could write that stale copy back over an AI edit.

Typing while a save was still writing left the tab believing it was clean, so closing it asked nothing; a file re-read from disk (after an AI edit, a branch switch) could land on top of typing that had just begun; and a slow format-on-save could splice its result over text typed after the save. All three now check the buffer again before touching it.

Typing anywhere outside the editor keeps its own undo.

Once per file now.

It existed (double-click a file, or F2) and nothing said so; a menu that offers Move to Trash but not Rename tells a person the only way to fix a name is to make a new file.

After a minute with nobody speaking,

Instead of three

When a call connects, Kaeru says hello in one

Fifteen seconds of silence ends a take (and a

Facts about *you* — how you

Say hi with a project open and Kaeru

Under the connector

The step-by-step proposal is its own numbered

The second tab was called History, its

It

It used to start a

Clicking through your

A cold

Every event since analytics shipped

A network-level

Dismissing an

A new page

"Put

Plain-language notes under each

Attach a file, and turn individual

The catalogue's browser

Select text in a rendered

It clicks and types on the running page, with

A page that publishes its own

A waiting plan now offers "Tweak

A button in the

Click anywhere in the readable view

Opening a note used to show its

If

Skills were

"Back up to GitHub" used

Talking to Kaeru used to

When nothing is running at the address,

Type

Drag

Deleting a conversation was one click,

It stays open while

Improving a prompt,

You used to have to press Enter, with

Starting your site answered a

Kaeru's

Using

Change something and the preview

Click

If a

The chat list

The sign-in panel shown

When a plugin

The pointer stayed an

The green outline used

It repeated what the

Plan first asked

Ask it

A new page it

A long

Typing /octo said "no

Picking it meant one

Built-in plugins are

The "Kaeru is now on v0.8.x, see

Every shell Kaeru opened got a

In a short pane

Kaeru refreshed the

The

Its

Kaeru knows which element you mean, so you don't have to describe where it is. Works on a local dev server preview.

Every match shows the lines around it, you can exclude any of them, and the button says exactly how many lines in how many files it will change. One undo puts it all back.

No terminal, no `git checkout -b`.

Commands and package names stay plain text, so a click never lands somewhere unexpected.

Nothing is deleted — the conversation, its files and its undo points all stay. Chats untouched for a month file themselves away.

Reopening gives back the width you had.

Every turn was failing before it reached the model, which looked like the AI being broken rather than one field in the wrong place.

It was mounting behind a font-loading step that never finished on macOS, so ⌘J opened an empty panel.

Sign in with Claude to use your subscription instead, or connect your own provider.

Toggle in the top bar.

EU-hosted, no accounts, off any time.