Changelog

What's new in Helix

Every release, in the words you'll see in the app. Helix updates itself, so these arrive on their own.

v1.22.02026-10-10Latest

A whole new look. Helix has its own identity now: a cool ink background with mint and violet accents, a subtle grain and dot texture, a new double-helix logo and small animations throughout - on the desktop app, the phone, the Chrome extension, the "Helix is working" glow and the site.
Learns your tasks and does them instantly. When a task works the same way twice ("open notepad and type …", "search YouTube for …"), Helix remembers it and next time does it directly in about a second, with no thinking. Press "Make this instant" on a finished task to teach it after one go. Manage them on the new Shortcuts page.
Faster on everything else too. Helix now plans several steps at once - open an app and type, open a page and read it - checks each one as it goes, and only stops to think again when something unexpected happens.
Clicks land on the right thing. Buttons on screen get small numbered tags, and Helix picks a number instead of guessing a position - no more pressing the wrong "Delete" when there are five of them.
Finds your files in under a second. "Find the PDF about taxes" uses Windows' own search index, including the text inside PDFs and documents.
Excel, Word, PowerPoint and Outlook. When Office is installed, Helix works with your spreadsheets, documents, decks and email drafts directly - reliably, without clicking through menus. Sending an email always asks first.
Shows its proof. When Helix can check that a step really worked ("window Notepad is open", "report.txt is on disk"), the task card says so.
Code: answers appear as they're written instead of after a long silence, and shell commands and tests stream live while they run.
Code: mistakes are caught the moment they're made. Every edited file is checked straight away, so a broken file gets fixed in the same minute.
Code: review every change. After each turn, open "Review" to keep or undo a single change, a whole file, or the entire turn.
Code: bring a stronger model. Add your own Claude or OpenAI-compatible key and Helix uses it for planning and reviewing; edits stay fast.
Code: knows its way around big projects with a ranked map of the files that matter, and fixes bugs test-first so the fix is proven.
Updates are more reliable. A dropped connection no longer restarts the download from zero, and a full disk is reported clearly.
Fixed: undo in Code no longer deletes very large files it could not back up; closing an app now closes only that window; typing is checked after it's done; Notepad, media keys and web reading are much faster.
Say several things in one go. "Open YouTube, then play Despacito" now happens straight away, one step after another.

v1.21.02026-09-22

"Send hi to Riya on WhatsApp" works first time, in seconds. Helix now sends WhatsApp messages with a fixed, checked routine instead of working it out step by step: it uses the WhatsApp Web tab you already have open, searches for the person, makes sure the right chat is open, and only calls it sent once the message shows up in the chat. Before, most of these took about a minute and many got stuck.
Helix asks instead of guessing who you meant. If two chats match the name ("Riya Sharma" and "Riya K"), or none do, Helix asks which one rather than picking. If WhatsApp Web isn't linked yet, it tells you how to link it.
"Play X on Spotify" actually starts the song. Helix opens the Spotify app straight onto the search, presses play on the top result without touching your mouse, and only says "Playing …" once Spotify shows the song playing. About 9 seconds even when Spotify wasn't open. "Play some music on Spotify" resumes where you left off.

v1.20.12026-09-22

"Open YouTube" happens in about a second. Simple requests (open an app or a website, search Google or YouTube, "play X on YouTube") are now done straight away, with no thinking, no screen reading and no permission question. Before, "Open YouTube" could take a minute and then ask whether it was okay. "Play X on YouTube" opens the actual video, not just a list of results.
Less thinking about easy things. Helix no longer deliberates before every task. It still thinks before long or multi-step ones.
The browser no longer gets stuck. If Chrome had no window open, Helix failed to open pages; it now opens a window itself. If Chrome dropped Helix's connection to a tab, Helix now reconnects instead of failing the same way over and over. If the browser keeps failing anyway, Helix switches to another way of doing the task.
The banner tells the truth. Instead of always saying "reading the page", it shows what Helix is actually doing ("step 2 · open youtube.com"), or "waiting for your OK" when it needs you.

v1.20.02026-09-22

Keep talking while Helix works. You no longer have to wait for a task to finish before asking for the next thing. While Helix is busy on your PC, questions are answered straight away, lookups and research run alongside it, and anything else that needs the PC is queued and starts by itself as soon as the current task ends. This works from the chat box, your phone, Telegram, Discord or Slack, a voice call, and "hey Helix". Type "stop" at any point to stop the current task.
Documents that look finished. Reports and documents Helix writes now have clear headings (even when the model forgets to mark them), a contents list for longer pieces, highlighted takeaways and warnings, nested lists, tables with numbers lined up, and citations like [1] that jump to the sources. Long links wrap instead of pushing the page sideways, and it all looks right in both light and dark mode.
Better PDFs. Documents print to proper A4 pages, with no headings stranded at the bottom of a page and no tables split across two.
Research reports carry their comparison table. When Helix compares options, the table is now in the report itself instead of only in the spreadsheet, and the key takeaways come first.

v1.19.12026-09-22

Updating from inside Helix works again. Pressing Update closed Helix and nothing else happened, and the next launch offered the same update again. There were three causes, all fixed. The installer shut itself down along with Helix. The small "patch" updates never started their final step. And the download site could hand out last week's installer, which then failed its safety check. Helix now closes, installs and reopens on the new version by itself.
If an update ever fails to finish, Helix notices. The next attempt uses the full installer instead of repeating what just failed, and says so.
Quitting Helix really quits. It no longer leaves a hidden copy running in the background, and the "hey Helix" listener stops with it instead of keeping the microphone open.
Updating no longer closes other apps' web views. The installer used to stop every Edge WebView process on the PC (Windows Search, Teams and others). It now stops only Helix's own.

v1.19.02026-09-21

Missions: hand over a coding goal and walk away. Describe the outcome and Helix plans it, works on its own branch in a separate copy of your project, and keeps going until the project's own checks pass. Nothing reaches your working tree until you look at the diff and merge. It survives restarts, pauses when the free allowance runs out, stops at a time or step limit, asks you (on your phone too) only before pushing or anything else that cannot be undone, and can open a pull request if you say yes. Start one from the Code page's + menu, or from Missions on the phone.
"Done" now means checked. Before code mode may say a change is finished, it runs the project's own tests, typecheck and lint on it, and fixes what fails. It then reviews its own diff once and fixes anything that makes the change wrong. A project with no tests is reported as unverified rather than passed.
It can see what it builds. A new preview opens the page in a headless browser, clicks through it, and reports console errors, layouts that scroll sideways, broken images and unlabelled buttons, plus a visual check of the screenshot.
Better debugging: it runs one failing test with its full traceback, finds the commit that broke something with git bisect (and restores your checkout afterwards), and refuses to finish with a breakpoint() left in.
Sets up a fresh checkout by itself: it creates the virtualenv and installs the dependencies the project declares (npm, pnpm, yarn, pip, go, cargo).
Works like a team. A mission can split independent parts across parallel helpers, each in its own copy of the project, and merge their work back.
GitHub: it reads issues, opens draft pull requests (always asking you first), and reads CI results and review comments so it can fix them. A workflow can start a mission from a webhook, so a GitHub issue can arrive as a branch with the fix on it.
The best model for each job. Planning and review ask the strongest model your key can use and fall back to the default when it can't; with a paid key they simply get better.
It remembers each project. It reads your HELIX.md, CLAUDE.md or AGENTS.md, and keeps its own notes on commands that work and traps it hit, without writing anything into your repository.
Long sessions stay sharp. When a long session has to be shortened, it now writes a real account of what is done, what is left and what it learned, instead of just a list of tool names.
Safer when working alone. A commit containing an API key or a private key is refused. Installing a package one letter away from a popular one (a common malware trick) and rewriting git history always ask first, even in bypass mode.
Just ask it to connect things. Say "connect GitHub" or "add the Postgres MCP" in code mode. Helix finds the server in its catalogue or the public MCP registry, asks you, connects it, and can use its tools on the very next step. You never have to open a settings page.
It makes its own tools. When Helix keeps doing the same job, it writes a small script and uses it as a tool from then on. You can read each one's code under Code > + > Its own tools, and each asks before its first run.
Hooks. Tell it "always run the linter after you edit" or "never touch generated/" and it sets up a hook that runs on every change. You can also add hooks yourself under Code > + > Hooks. A project's own .helix/hooks.json only runs after you trust it.
Explore. Broad questions like "where is X handled?" go to a read-only helper that answers with file-and-line references. The main conversation stays focused on the work.
Edits are safer. Helix must read a file before it changes it. If you (or a formatter) changed the file since then, it reads it again rather than overwriting your change. An edit that breaks the syntax is flagged right away, not at the end.
Long output is never lost. A huge test log shows its start and end, and Helix can search the middle without re-running anything.
It keeps its plan honest. It is reminded when its plan goes stale, and cannot say "done" with plan items still open.
Updates install when you quit. Once an update has downloaded, it installs by itself the next time you quit Helix, so the next launch is already the new version. Helix now checks every few hours, and switching off "Look for updates" now really stops the checks.
The phone app updates itself. Tap Update and the new version downloads inside the app with a progress bar. It is checked against its published checksum, then handed to Android's installer. The app also checks again when you come back to it, not only at launch.
More on the phone: Projects and Artifacts in the Library, and a "More" sheet in Code that shows project memory, Helix's own tools and hooks (with an on/off switch for each hook).

v1.18.02026-09-21

Voice calls now run on Gemini 3.8 Live. It answers faster, sounds more natural, and keeps talking while it works. You can pick Gemini 3.8 Live Extended Thinking in Settings for harder questions; it thinks while it talks, and if Google's side fails mid-answer the call switches to 3.8 Live and asks again, so you never have to repeat yourself. The previous model is still available.
The voice no longer says something is done before it is. When you ask Helix to do something on a call, it says "on it" and tells you it finished only when the task has really finished.
Long calls no longer drop. Google ends a voice connection after about ten minutes; Helix now opens the next one before that happens and the call carries on, remembering what you were talking about.
Say yes out loud. When a task needs your approval during a call, you can just say yes or no. You can also ask Helix to remember something, schedule something ("every weekday at 8, summarise my mail"), or let you take over, all by voice.
Helix knows more when you call. The call starts knowing the date and time, who you are, what it remembers about you, what is running or waiting for you, and the last few messages in the chat.
Take over, then hand back. When a task reaches something only you can do, like a sign-in, a CAPTCHA, a code sent to your phone or a card number, Helix pauses and asks you, on your phone and your PC. Do it at the PC or from your phone with remote control, press Hand back, and it looks at the screen again and carries on from where things are. You can also press Take over yourself at any time during a task. If nobody hands back within 30 minutes, the task stops and says why.
Work you hand over survives a restart. Jobs used to live only in memory, so a crash, an update or the server running out of memory lost them without a word. They are now saved as they go: queued ones run when Helix comes back, a lookup that was cut off is tried again, and anything that was clicking or sending is *not* repeated. It is marked interrupted and you are told, so nothing goes out twice.
Webhooks on your server. A workflow can now start the moment Stripe, GitHub or a form calls it. Turn it on with --hooks PORT when installing. That port answers only /hooks/<workflow>/<secret>, retries never fire twice, and the rest of Helix stays private.
A daily summary. At 08:00 a server sends your chat apps and phone a few lines: what ran, what failed and why, what is waiting on you, how much allowance is left, disk, memory and uptime. It also tells you straight away if it was down. helix digest shows it any time.
A missed schedule on a server still runs. If the server was down or busy at 08:00, the job now runs once when it can, and says how late it is and why, instead of silently skipping the day.
Work nobody asked for has a daily limit. Schedules, workflows and webhooks can use 60% of the day's model allowance and 40 runs, so a loop at 3am cannot leave you with nothing. You are told once when work is held, and anything you ask yourself still runs.
"Nobody answered" is no longer reported as "denied". When a step needs your OK and no one replies in time, it is skipped, and the answer now ends with what was not done and why.
Servers look after their own memory and hangs. Idle browsers are closed when memory runs high, a browser is refreshed every 20 minutes, the service has its own memory ceiling so a leak can never take the machine down with it, and a frozen Helix is restarted automatically within three minutes.
Desktop steps are much quicker. After each action Helix used to wait for the whole screen to stop changing - and on a real desktop something is always changing (a clock, a cursor, a video), so every step waited the maximum. It now watches the window it is working in and carries on the moment that window's contents settle: about a fifth of a second instead of one to two.
Helix can fill in payment boxes, sign-in popups and cookie choices. Those usually live inside an embedded frame from another website, which Helix could see was there but could not look inside. It now reads, clicks and types inside them.
It will not press a button in the wrong window. If another window pops up while Helix is deciding what to do next - a notification, a dialog, you clicking somewhere else - it stops and looks again instead of pressing "OK" or "Delete" in a window it never saw.
Drive backups no longer lose documents. Two documents with the same name from different tasks were saved over each other, so only one of them was actually backed up - and both were re-uploaded on every backup. Each is now kept separately, and unchanged files are left alone.
Browser steps are much quicker, and much harder to get wrong. Helix now takes one *snapshot* of a page - where it is, what is in the way, what the page says and everything it can press - in a single look, instead of reading the page, listing the elements and checking the address separately. All of it now describes the same instant, so it can no longer quote a sentence about a button that is not in the list.
It stops waiting the moment the page responds. Every click used to be followed by a fixed pause in case the page was about to navigate. It now watches for the page actually reacting and carries straight on: measured at 742ms -> 21ms for a click that opens a menu.
It will not click something that changed while it was thinking. On a chat list or a mailbox the rows get reused, so the thing Helix decided to click can quietly become a different conversation before it gets there. Helix now checks that what it is about to press is still what it looked at, and stops and looks again instead - it cannot take back a message sent to the wrong person.
Reading a page no longer picks up things you cannot see. Text inside closed menus, collapsed sections and hidden dialogs was being read back as if it were on screen, along with the page's own scripts and stylesheets. That wasted room in every reply and, worse, told Helix a menu was already open when it was not.
Reading a listing page gives you the listing. On a home page, a blog index or a product grid, Helix could come back with a single card - it took the first <article> on the page and treated it as the whole page. On MDN's front page that was 254 characters of a 4,900-character page. It now recognises a listing and reads all of it.
Your phone stops buzzing when you are sitting at the computer. Helix now works out where to reach you: at the machine, the window in front of you gets it and your phone stays quiet; away from it, your phone is told. An approval that stops a task and goes unanswered for two minutes reaches your phone anyway - being at the keyboard is not the same as reading the screen, and a task parked all afternoon is worse than one extra notification.
A question asked while your phone was out of range still gets asked. If Helix needed your OK while you were away, the request could be lost behind the ordinary run updates before your phone came back - so you returned to a task sitting there stopped, with nothing on screen saying why. Requests and finished-task notices are now kept separately and are waiting when you reconnect. One that was already dealt with at the computer does not come back as a question.
When your phone cannot reach a machine, Helix now says why. The status used to read "closed" whatever had happened, and kept retrying identically for ever - including when the machine had been signed out from another device, which no amount of retrying fixes. Each cause now has its own sentence: no internet, something on the network refusing the connection, or signed out and needing linking again. The pairing screen shows it too, above the code - because it is the reason the code will not work.
Your phone stays quiet when the computer already told you. Notifications on the phone now follow the same judgement: if you were at the computer when something happened, the run card still updates but nothing buzzes.

v1.17.02026-09-14

Talk to Helix from Telegram, Discord and Slack. Connect a bot of your own (helix telegram, helix discord, helix slack, or Settings, Chat apps) and message it: questions, research and tasks work there, it says when they are done, and it asks - with buttons - before anything that needs your OK. It works on a server with no open port. Nobody reaches Helix through it until the code their chat was sent is approved on one of your signed-in devices, in the same Link a device box a new server uses.
Scheduled briefings, sent to your chat. /briefing 08:00 my calendar and anything urgent in my mail in the chat, or Send the result to on the Schedule page for any standing instruction.
Your machines hand work to each other by themselves. A server that reaches a step needing a screen hands it to your PC and carries on with the result, and Helix can send a document it made to another of your machines and open it there. It asks before handing anything over, in the default approval mode too, and work that was handed over is never handed on again.
Long research can run on your server. Asked for on your PC or phone while a server of yours is online, Helix offers to run it there - so it keeps going if the laptop sleeps - and opens the result on the PC when it is done. Where long research runs is a setting: ask, always the server, or always here.
A question a machine is waiting on can be answered from any of your devices - the desktop, your phone, or the chat app the task came from.
Connect Google once, and every machine has it. A server cannot show Google's consent screen, so Gmail and Calendar there needed an SSH tunnel. Now helix google on the server - or a task there that needs Gmail - asks your devices, and a yes on your phone or PC has the machine that already has Google send it over your account's private channel. Nothing moves without that yes, and disconnecting Google on any machine ends it on all of them.
Fixed: the server installer's --beta installed the stable build. It now fetches the beta, and a server installed that way stays on the beta when the installer is run again to update it.
Fixed: tasks on a server stopped at their first step with "There is no screen on this machine", even ones that needed no screen. A server now works without one from the start, and hands any step that needs a desktop to your PC.
Fixed: helix on a server whose name has a space or an apostrophe printed "not found" before every command, or would not run at all.
Fixed: other accounts on a server could read your sign-ins. The files holding the Helix session, Google's access and the device's secret were readable by everyone on the machine. Helix's data folder is now private to its own service, and those files to it alone.
Fixed: a server that could not start was restarted forever. The limit of ten restarts in five minutes was written where systemd ignores it; it is now where systemd reads it, so a broken install stops and says so in the log.
Fixed: a busy machine dropped off your devices for a few seconds. Realtime allows five presence updates in thirty seconds and closes the channel on the sixth, and a task starting and stopping while settings changed was enough. Updates are now spaced and merged, and a request to a machine that is rejoining waits for it instead of failing.
Sign a server in with a code, not a tunnel. helix link on a server shows a code and a QR; enter it in Helix on your phone or PC (Settings, Link a device) and the server is signed in to your account with a session of its own. You are shown which machine asked, from where and how long ago before you approve, the code works once for ten minutes, and the installer offers to do it the moment it finishes.
Your phone finds your machines by itself. Sign in with Google and every PC and server on your account is listed; tap one to connect, no pairing code. With exactly one online and nothing paired yet, it connects on its own.
Your machines work together. Every Helix signed in to the same account shares one private channel: helix send "PC" "..." gives another machine a task, the desktop's device list has Send a task, and a task finishing on one machine is announced on the others. A machine can refuse all of it with one setting.
Settings follow your account. The ones marked synced - how much Helix writes back, how it reasons, how many pages research reads and more - change on every device within a second of changing on one. Settings that describe the machine, like when it asks before acting, stay with the machine.
Every setting in one list. helix config on a server and All settings in the desktop app show everything you can change, where each value came from and what it accepts. One list, so a new setting appears in both.
helix does it all from a terminal: status, devices, send, doctor --fix, config, logs, update and uninstall, as well as giving it tasks.
The installer takes options - --name, --port, --key, --with-node, --with-vastra, --no-setup - keeps a custom port across updates, and can remove Helix again with --uninstall, keeping your data unless you add --purge.
Fixed: signing out on one device signed you out everywhere. Sign-out used Supabase's default, which ends every session on the account - your phone's and your server's included. It now ends only the one on that device.
Fixed: reinstalling gave your PC a new identity, so phones paired with it lost it. The identity now lives with your data rather than the program, and a brand-new data folder - a container, a second server - always gets its own.
Fixed: "ready" with no API key. A fresh install said its model was ready while every request failed for want of a key. It now says there is no key, and how to get one.
Fixed: every machine in your device list read as never seen, and one that lost power stayed "online" for a minute and a half. Online now comes from the live channel.
Commands work on a server. Every shell command on a Linux box came back "file not found" - Helix was still reaching for cmd.exe and PowerShell on a machine that has neither, for the very thing it is told to prefer. It now uses the shell that is actually there, is taught the right recipes for it, and knows which commands are dangerous on Linux rather than only on Windows.
A task that runs out of the free allowance carries on by itself. It always could; almost nobody got it, because it was off unless you found the setting. It is now on for everything that does not need your screen - research, mail, documents, code, anything scheduled - and still asked for before Helix picks your mouse back up.
Running out of the allowance is explained the same way everywhere. The desktop, the phone, the waiting card and your history used to each describe it differently, one of them with a backend error that reads like a crash. One sentence now: what ran out, that nothing was lost, and what you can do.
Your machines, in one list. A PC and a rented server are two Helixes on one account, and nothing could see both. Settings now lists every computer, phone and server you are signed in on, and marks the one you are looking at.
Your phone remembers every machine it has paired with, and switches between them with a tap. It used to hold one, so reaching a second meant pairing again and losing the first.
A server introduces itself as one. It appeared in your device list as its hostname - vps-48213 - and announced a screen size it does not have.
"What is set up" answers before anything goes wrong. One list: your key, the model, the screen, the browser, Google, your connected tools and today's allowance - each saying what is true and what to do about it. It knows the difference between a fault and a fact: a server having no screen is not a problem to fix.
Helix in your terminal. On a server, helix now opens a terminal you can give a task to - no tunnel, no port, no browser. It draws the run as it happens, each step and what came back, and Ctrl+C stops the run without leaving. helix --task "..." runs one task, prints what happened and exits, which is what a script or a cron line wants. It is a client, not a second Helix: a task started there can be watched from the web UI or your phone, and all three are looking at the same run.
Helix can drive Vastra, and prefers it. If Vastra is running with its Agent API on, Helix uses it as its browser instead of the Chrome extension - and gets things the extension cannot do. It can click a control by DESCRIBING it ("the blue Send button") rather than by guessing a selector, so a page redesign stops breaking tasks. It can reach any of Vastra's 536 commands by name. And a click decided from a page that has since moved is refused rather than landing on whatever is there now.
Sign in once, and everything after that is signed in. Sign into Google in Vastra and every tab Helix opens is already signed in - Gmail, Drive, YouTube, and anything offering "continue with Google". Where Vastra has a saved login it can fill it, after asking you. Helix never sees, stores or types a password.
A wall is handed back to you, not hammered at. A captcha, a code from your phone, a "sign in first" - Helix says so and stops, rather than spending its whole run on a page it was never going to get past.
Your server can have a real browser too. HELIX_WITH_VASTRA=1 on the install line puts Vastra on the VPS as its own service, so a machine with no screen can still research properly and do things behind a login. It wants a 2 GB box rather than the 512 MB Helix alone is happy on.
A missing MCP runtime says what to install. Connecting a server that needs npx on a machine with no Node used to fail with an errno and the name of a program you never typed.
Chrome is still there. Nothing changes if you do not have Vastra, and Helix falls back to the extension the moment Vastra is not running.
Helix on your own server, in one command. Rent the cheapest VPS you can find, paste one line, and your agents are running 24/7 on a machine you own - researching, coding, answering mail and keeping to a schedule while your laptop is shut. It installs Python if the box has none, runs as its own user with no shell, starts itself after a reboot, and running the command again upgrades it without touching your sign-in or your history.
It fits on a 512 MB box. A server needs none of the desktop half of Helix, so it does not install it: the whole thing comes to 38 MB instead of about 300, which is the difference between a 24/7 agent costing a coffee a month and costing a dinner.
Nothing is put on the open internet. The server listens only to itself. You reach it with one ssh line from your own computer to sign in, and after that your phone reaches it from anywhere over the same cloud link it already uses - no open port, no password on the internet.
A machine with no screen says so. Every run on a server is a background run, so anything needing a desktop is refused with the browser call that does the same job, instead of failing somewhere inside a screenshot.
The other assistants are yours to use. You are signed in to ChatGPT, Claude, Gemini and Perplexity in Chrome, and Helix can now put a question to several of them AT ONCE - a tab each - and tell you where they agree, where they disagree and how confident that makes the answer. One of them showing a sign-in wall no longer spoils the rest, and one answering alone is reported as one opinion rather than dressed up as agreement.
If Helix cannot do something, it finds the account that can. No image key, or the model would not draw it? It hands the job to whichever assistant you are signed in to that draws, and saves the picture on this PC as if it had made it itself. The same route works for research and for anything else a connector says it can do - and you can ask for it directly: "get ChatGPT to make me a logo".
Ask what your accounts can actually do. Helix will list what the sites you are signed in to can be asked for, so "can you make a video" has a real answer instead of a guess.
The second opinion inside research finally happens. Research could always cross-check its findings against the other assistants, and nothing ever switched it on - the whole cross-check was code that could not run. It now runs when the question is a judgement call ("is this true", "should I"), and there is a setting for always or never.
Fixed: a connector you had ever switched off and on again silently lost what it could do, so Helix stopped offering it for pictures or research.
Helix can draw. Ask for a poster, a logo, an icon, a thumbnail or a background and you get a real picture file on this PC, in the folder you named - or in Pictures/Helix if you did not name one. It never overwrites a picture you already have.
And it can change a picture you already have. Point it at one and say what to change - "remove the background", "make it night" - and the new version is written next to the original, which is left alone.
The tools you connected work everywhere now. MCP servers used to be visible only on the Code page: everywhere else Helix behaved as though they did not exist. The main run can use them too, so a tool that answers a question in one request is used instead of ten minutes of clicking. It still asks before it runs one - Helix cannot see what somebody else's server does, so it never assumes.
Research goes back for what it could not find. Every report ended with a list headed "Not answered by the sources" - and nothing ever acted on it. It now reads its own list, searches again for exactly those questions, reads the new pages and answers them, and only what is *still* missing is left under that heading. If the first pass answered everything, nothing extra is spent.
Research waits less. The three to five searches behind a report went out one after another; they now go out together, so that part of the wait is roughly halved. A page read once is remembered for a few minutes, so going back for a second round - or asking about the same thing again - does not pay for it twice.
A page that never loads can no longer take the whole report with it. One site that hangs used to end the run with nothing; the pages that did answer are now used, and the report says how many were left out.
Helix can look things up while it codes. Code mode had no way to see anything outside your project, so an unfamiliar library or an error it could not place was a guess. It can now search the web and read a page - the documentation, a changelog, an issue thread - and it is told to do that rather than guess at a function it half remembers.
A coding step no longer reads its files one at a time. When it asks for three files, a search and a diff in one go, they now happen together.
Ask Helix to fix something in a project and the coding agent does it. Until now that only worked on the Code page: from the chat, it had a shell and a file writer and nothing else - no sense of the project, no way to run your tests, no undo. The same job asked for in the chat, on the desktop or the phone, now goes to the coding agent, appears in the Code page's history afterwards, and asks you about anything risky in the same dialog it always did. It comes back with what changed, not a wall of output.
Stop stops a coding run too. It used to end the step that started the work while the coding agent carried on editing files.
Each step carries less. Helix was sending the same wall of instructions on every step of every task - how to use PowerShell, how to control the volume, how to read a video - whether or not the task had anything to do with any of it. It now sends what the task actually needs, and brings the rest back the moment it turns out to need it. Between a sixth and a third less on every step, and nothing it can do has changed.
Fewer round trips. Opening an app and then typing into it used to cost one turn per keystroke. Helix is now reminded, at the moment a window opens, that it already knows the whole sequence and can send it at once.
Other websites can no longer talk to Helix. A page you visited in your browser could reach the copy of Helix running on your PC - read your task history, your saved settings and what Helix had learned, change settings, and take the pairing code that lets a phone connect. It could do it because the request came from your own machine, which was all Helix checked. It now also checks WHO sent it: its own windows, the Helix app, and the extension are let in, and nothing else is - whatever address it arrives from. Nothing you use changes.
The pairing code is no longer readable by a web page.
Pause. A run can be held where it is and picked back up, from the desktop or the phone. The button was the only part missing.
You are told when a rule you set stops something. If you say "do not send anything" and the task reaches for a send, that now appears in the thread instead of happening silently.
Settings will not accept nonsense. A bad model name or address used to be saved as given, and came back broken after a restart.
Android: the app no longer closes itself when a task starts in the background. The part that keeps Helix connected while you are in another app was being refused by Android 12 and newer, and the refusal was killing the app. It now carries on without it and says so.
Android: Helix asks before it taps Send, Pay or Delete on your phone. It always asked before doing those on your PC; driving the phone itself, it did not.
Android: a tap the phone refused is no longer reported as done.
Answers are written, not printed. An answer that came back with a heading, a list, a table or a command in it used to show you the markup instead of the writing - stray asterisks, rows of pipes, backticks around every filename. It now reads the way it was meant to. Plain answers are untouched, and what you typed is still shown back to you exactly as you typed it.
You can copy things. A copy under every message, and one on every block of code, both out of the way until you point at them. Copying an answer gives you the text as it was written, ready to paste anywhere.
A way back to the bottom. Scroll up through a long run and a small "Jump to latest" appears, with a dot if something arrived while you were reading. It is gone the moment you are back at the end.
The thread no longer fights you while it is answering. Every arriving line used to start its own scroll animation and interrupt the last one, so a long answer scrolled in fits. It just follows now.
Helix can work in the page you already have open. It used to be able to see your tabs and touch none of them, so "summarise this page" or "what is wrong with this form" meant opening the site again in a tab of its own - signed out, and not the page you were looking at. It can now take the tab you are on, in your own session. It says which page it has taken, and it cannot close a tab of yours: when it is done it simply lets go.
Your phone and your PC share a clipboard. Pull whatever is on your PC's clipboard into your hand, or send a line the other way and paste it there. It was built and had no buttons.
A phone can disconnect itself. Until now only the PC could do it.
New: Skills. Write down how *you* want something done - which sheet the weekly report comes from, that mail is always drafted and never sent - and Helix reads it before it plans. Describe it in a sentence and it writes the skill for you. Anything a skill says it must ask about first is enforced, not just suggested. All of this existed and had no way in.
You can clear the Artifacts shelf. Remove takes something off the list and leaves the file exactly where it is.
Fixed: a permission question could be lost. If you reloaded while Code mode was waiting on your answer, the question vanished and the job quietly refused itself a few minutes later. It comes back now.
You can delete a code session from your phone.
"Hey Helix" no longer takes over your screen by mistake. Something that sounded close enough - a video, music, somebody else talking - could bring Helix to the front and open a live microphone, and leave it open. Now a second mishearing straight after the first is ignored, and a call nobody speaks into closes itself after a few seconds and says so. A call you start yourself is never closed for you.
Opening a project is a folder picker now, not a typing exercise. Code mode used to ask for the full path to your folder. It opens Windows' own folder dialog, and if that is not available it browses your drives inside the app - with a note on folders that look like a project, so you do not open the one above it by mistake. Pasting a path still works if you prefer.
You can open a project from your phone. It used to say "open a project on your PC first" and leave you there. You can browse your PC's folders and pick one from the sofa.
Fixed: a phone could pop a folder dialog on your PC and leave it sitting there waiting for somebody to close it.
The Chrome side panel stops contradicting itself. After you asked it something, the box would unlock again a second later and the status would flick back to "connected" while Helix was still working - so you could fire a second question at it by accident. It now stays busy until the answer actually arrives.
Answers in the side panel read properly, the same as everywhere else, and every message there can be copied.
Chrome shows you what Helix is doing. The extension button now carries a small mark while Helix is working - and a clearer one whenever it is working in a tab of yours rather than its own, with a tooltip saying which. Nothing at all when it is idle.
Fixed: the Chrome extension on the download page was built by hand, so it could sit several versions behind everything else in a release. It is built and checked as part of cutting one now.
Your unsent draft is still there when you come back. Close Helix, or let it restart for an update, and whatever you had half-written in the box is waiting - not focused, not in your way, just there.
A failed request hands your message back. If something goes wrong - no key yet, your PC not reachable - the error now comes with a Try again that re-sends exactly what you typed, instead of leaving you to write it out a second time.
Helix picks the right instructions more often. Odd fragments left over from ordinary words - the "s" in "the user's", the "i" in "can i" - were being treated as real search terms, so a handful of unrelated notes scored on almost every request.
More of what Helix knows reaches it. When it gathered up everything it had remembered for a task, a section that turned out not to fit still used up part of the space - so something else got cut to make room for text that was never included.
Helix actually learns the useful part now. What it remembered about a past task recorded that it had, say, searched the web or messaged someone - but not what it searched for or who it messaged. Anything newer than clicking and typing was stored with the important half missing and then offered back as a proven route. It keeps the whole step now.
Fixed: learning could be thrown away without a word. If your memory file lived anywhere but the default place, nothing was ever written to it and nothing said so.
"Add files" and "Add folder" do something now. Both used to answer "Coming soon". They open your PC's own file picker and drop what you chose into the box, ready for you to say what to do with it - read it, summarise it, work through the folder.
Helix stops working the network when you are not looking at it. Five background checks used to run non-stop for as long as the window was open - about a request every two seconds - whether it was on screen, minimised, or on a closed laptop. They pause now and catch up the instant you come back, so nothing is ever stale when you look.
Help & shortcuts lists all of them now. Search (Ctrl+K) was on the toolbar and missing from the list, and the document reader's keys were never there at all.
Up-arrow brings back what you sent. From an empty box, the way it works in a terminal - Up walks back through this session's messages, Down walks forward. Start typing and it gets out of the way.
Edit what you asked, or ask again. Hover any message: your own can be put back in the box to fix a typo without retyping the whole instruction, and any answer can be asked for a second time. Editing adds a new turn rather than rewriting what was already said.
Code mode on the phone can finally show its work. Replies from the coding harness arrived as one unbroken paragraph - every line break gone, and never a list, a table or a block of code. They read properly now, and code blocks there have a copy button too.
Documents opened on the phone are rendered by the same reader as everywhere else, so a report reads the same on your phone as on your PC.
The phone got all of it too. Answers read properly there as well, and a long press on any message copies it - the way it works in every other app on that device.
Fixed: a link in an answer whose address contained a quotation mark could put its own markup into the page. Answers built from web pages were the way in.
Fixed: the morning brief was drawn with no panel behind it; the dot on the "Controlling your PC" banner ran the wrong animation; and three colours ignored your theme and stayed the same in light and dark On the phone, the step Helix was actually working on looked no different from the ones it had already finished.

v1.16.22026-09-02

Updating no longer gets stuck. A small update told Windows to swap the folder and then never closed Helix — so the swap waited for an app that was still running, gave up, changed nothing, and left the window on "Installing…" for ever. Helix now closes itself, which is also what lets the folder be replaced cleanly.
An update that fails gives you your app back. If installing went wrong the installer stopped with no window, no message and nothing running — the app had already been closed to make way for it. It now writes down what happened and restarts the version you were on, so "it restarted and nothing happened" cannot end with no Helix at all.
The update dialog stops lying about progress. If the install has not started after a reasonable wait it says so, tells you nothing on your computer has changed, and offers to run the downloaded installer for you.
Small updates now reach people who skipped a release. Only one patch was published — from the release immediately before — so missing a single update meant downloading the full 122 MB every time after that. Patches are now published for the last four releases.
Your account says whether a key changed on another device reaches this one in about a second or on the slower check. The two are indistinguishable while nothing is changing, so the only moment you would have found out was the moment it mattered.
Helix now looks for updates at helix.vyomagroup.online. The old address keeps receiving every release, so apps installed before this go on updating normally.

v1.16.12026-09-02

A key saved on another device in the first moment after Helix starts is no longer missed. The instant-sync watcher reported itself ready a fraction of a second before it actually was, so a change landing in that window waited for the slow check instead of arriving straight away.

Always on the latest.

Install once; Helix keeps itself up to date.

Download for Windows Try Helix in your browser