Changelog

​

Agents that ride out disconnects, an Apps console, and shortcuts everywhere

• Agents keep going when a machine blinks A tool call no longer fails the instant a machine drops for a few seconds during an update, and a chat that was paused because its machine stayed offline resumes by itself once the machine is back. A sub-agent that stopped on an error can be resumed by sending it a message, a message to an agent now cuts short a long wait instead of sitting unread, and agents can wait out a machine disconnect.
• Cloud machines sleep when nobody asked for work, and warn before the disk fills A machine is now kept awake only by work a person or an agent asked for, so background polling and an open tab no longer stop it from sleeping. Disk warnings now cover the volumes that actually fill up, the storage item in your Inbox returns only when the disk gets worse, and where your plan allows it you can grow a machine’s disk from its settings. Creating a workspace shows Creating… and reports success only once it is ready.
• Apps, with logs, traces and metrics for each environment Deployments is now called Apps and sits directly under New chat. Each deployed environment gains an observability console with logs, traces, metrics, profiles and dashboards, plus alerts and release dashboards, and usage shows your allowance, any overage and quota messages. The per-branch Changes and Checks tabs are gone; look at your CI builds instead.
• Enable a workflow’s triggers in one step A workflow’s page now has Enable and Disable for all of its triggers at once, with a card showing the state of each one; if one trigger is missing a connection, nothing is enabled and the dialog names it. Automations can act as the Reliant bot instead of as you, trigger filters can read who the automation belongs to, and built-in workflows now review pull requests, work issues you opt in, respond to review feedback and triage alerts.
• Keyboard shortcuts on every screen and in the browser Shortcuts now work in Settings, the Inbox, Workflows, Runs and Apps, not only in the chat view. In the browser they match the physical key, so they work on non-Latin layouts, and they no longer collide with browser shortcuts. In the desktop app the Navigate menu items now work, they no longer break text selection in the composer, and Cmd+Tab brings a window back when none is open.
• Your chosen provider follows into sub-agents The provider you pick for a chat now carries down to its sub-agents. Chats pinned to Gemini previews, Gemini 2.5 on Vertex or gpt-5.2-codex, which their providers have shut down, move to the provider’s replacement with a notice, and gpt-6.1-sol now works through a ChatGPT account in Codex.
• Smaller fixes Agents create worktrees where the app shows them, instead of folders inside your project, and a clean, squash-merged worktree is now cleaned up. A bad branch or base name is reported as a clear message. The detected-ports chip opens its menu when clicked, and the terminal takes focus only when you ask for it.

​

Messages that always arrive, GPT-6.1, and cloud machines you can resize

• A message you send always arrives A message sent while your machine was down, or while a run was failing to start, could disappear. It now waits for the machine and is delivered once it is back, and a run that stalls carries your message on rather than dropping it. A new chat’s first message shows at once, a send that does fail says Not sent with a Retry button, and sending the same message twice can no longer post it twice.
• GPT-6.1 models are available GPT-6.1 models join the model list, and gpt-6.1-sol, gpt-6-sol and gpt-6-luna are offered through Codex. A send never refuses a model its provider cannot serve: it moves to the same tier on a provider you have connected. Every model and provider pair now uses its published context window and output limit.
• Resize a cloud machine from settings Cloud machines can be resized from settings. A workflow that starts while its machine is waking now waits for it instead of failing, Try again on a failed machine actually resumes it, and a machine whose workspace volume was lost restarts its container instead of sitting broken.
• Git credentials are fetched when needed and never stored on the machine A cloud machine now asks for your current git token at the moment it needs one, instead of keeping a token on disk.
• A fresh chat starts lighter About 150,000 tokens of duplicated memory and skills no longer load into every new chat, and conversations no longer get stuck repeatedly compacting their history without making progress.
• Smaller fixes Disconnecting a provider says which one and confirms the rest stay connected. A stale page no longer freezes a tab in an update loop. A long press on mobile no longer starts a text selection that hides the actions sheet.

​

Our biggest update yet

• Forge: production-grade code from the first prompt Reliant now includes forge, a scaffolding framework that keeps your LLM writing production-grade code.
• Cloud dev-boxes that work while you sleep Reliant dev-boxes are hosted in the cloud, so your agents keep working after you close your laptop.
• Workflows that connect to GitHub, Slack, Gmail and more Workflows can now start on a schedule, a webhook, or an event in GitHub, Slack, Gmail or Twilio, and they can act in those tools too.
• Run Reliant from the web, your phone, or the desktop Start and follow your agents from the web app at app.reliantlabs.io, from your phone’s browser, or from the desktop app, all on the same chats.
• Update your desktop app Desktop versions older than 1.8.0 can no longer start new chats. The app offers the update on its next launch, or run brew upgrade —cask reliant.

​

Claude Opus 5.5 arrives, workflows can be saved as drafts, and long conversations stop running into a wall

• Claude Opus 5.5 is available, and it is the flagship pick Claude Opus 5.5 is available through Anthropic, OpenRouter, Vertex AI and Reliant’s own provider. Choosing the flagship model now gives you Opus 5.5 on each of them, with double the output length of earlier Claude models. The choice of a merely powerful model is unchanged, so nothing you have already configured quietly becomes more expensive.
• Workflows can be saved as drafts A workflow you are still building no longer has to be valid before you can save it. Drafts always save, carry a Draft badge in the builder, and are never offered anywhere a runnable workflow is needed. When it is ready, mark it complete — at which point it is checked in full, and a complete workflow that fails its checks offers to go back to being a draft instead of throwing your edits away.
• Long conversations no longer end without warning Every run keeps a history of what it has done, and that history had a hard size limit. Large tool results and file contents counted against it, so a long, busy conversation could hit the limit and be stopped outright. Bulky data is now stored alongside the run instead of inside its history, and a run that does need a fresh start carries its background agents across with it rather than abandoning them.
• Signing in from the command line happens in your browser reliant auth login now opens your browser, asks you to approve the sign-in, and stores a single kind of access token that the whole product understands. Personal access tokens from earlier versions no longer work and the reliant context command has been removed — run reliant auth login once to get a new token.
• The desktop app replaces an out-of-date saved credential on its own After the change to access tokens, a machine could hold on to a saved credential in the old format and sit disconnected, since that credential can no longer sign in. The desktop app now recognises an old-format credential, removes it and fetches a new one, including when the server is still starting and the first attempt has to be retried.
• The terminal no longer leaks sessions until your machine runs out Each time the terminal reconnected — after a reload, a laptop sleep or a network blip — the shell it had been using was left running with nothing attached to it. One machine collected more than five hundred of them in two days, which used up the system-wide supply of terminals: after that, every program on the computer failed to open one, Terminal.app included. Closing a connection now closes its shell, and each machine caps how many it will keep open, so a problem of this kind can no longer spill beyond Reliant.
• Onboarding no longer stops on an empty screen Setting up with your own computer and your own API key ended on a card with nothing on it but a Continue button, because there was nothing left to set up. That step now finishes by itself and moves you on. A setup that did have work to do still shows its checklist and still waits for you if anything failed.
• The last traces of a free machine trial are gone Reliant does not offer a free trial machine, but the upgrade prompt could still describe one as having expired, and the billing screen still made an exception for a free plan that no longer exists. Both are gone, so the app no longer mentions a trial you never had.

​

Antigravity joins the provider list, a failed branch no longer breaks the chat it came from, and the app stops telling you things are fine when they are not

• Antigravity is available as a provider You can now connect Antigravity, Google’s agentic coding backend, the same way you connect Claude or Codex — sign in with Google and it appears alongside the others in settings, onboarding and mobile. Image generation is included through the existing tool, so nothing new to learn. Connecting a third provider also fixed a class of bug that only a third provider could expose: several places in the app chose between exactly two providers and quietly routed anything else to the wrong one, so signing in could attach the wrong account with no error shown anywhere.
• A branch that fails to create no longer breaks the chat Branching a chat into a worktree could fail for ordinary reasons — a name that collides with an existing branch, for instance — and the failure left behind an empty directory and a workspace record pointing nowhere. Every later file request for that chat then failed, blaming the project rather than the branch, which sent you looking in the wrong place. A failed branch now removes what it created and the chat falls back to the project checkout, so a failure costs you the attempt and nothing else.
• The terminal admits when its machine is gone The terminal connects through the server rather than straight to your machine, so when the machine went away the connection stayed open and the terminal kept showing a healthy prompt for something that no longer existed. Chat and the connection banners had it right; only the terminal was wrong, and only a refresh corrected it. It now notices and says so, with enough delay to ride out a brief reconnect rather than ending healthy sessions.
• An out-of-date machine says so instead of reporting an internal error Sending a command to a machine running an older build produced an opaque internal error naming only the command. That shape reads like a bug worth reporting, when the answer is simply to update. It now names the version it is running and what to do about it.
• A model that is unavailable tells you to pick another one A model listed in the catalog but not actually available on the backend returned a raw provider error mid-stream — a block of JSON naming infrastructure you have never seen. It now names the model you picked and tells you to choose a different one.
• Reliant AI is no longer switched on for accounts that never purchased it Selecting the Reliant provider during onboarding without completing the purchase still enabled it, and the resulting refusal blamed a shared free-tier budget — a mechanism that no longer exists. Access is now granted only at the point of purchase, and when credit runs out the message says so in its own words. References to a free tier have been removed from the product, since we do not offer one.
• Background commands keep running on their own Background commands are now detached by the component that actually owns the process, so a long-running command started in the background is no longer tied to the lifetime of the request that launched it.

​

Cancelled commands clean up after themselves, images survive the trip, and a workflow gets exactly the tools it asked for

• Cancelling a command no longer leaves git wedged A cancelled subprocess was killed outright, so it never got to clean up after itself. Git made this visible: killed mid-write, it leaves behind a lock file it cannot remove, and every later git operation in that repository then fails while blaming a process that is no longer running. One was found still blocking work twelve hours later, fixable only by deleting a file by hand inside .git. Cancelled commands are now asked to stop first and given a moment to tidy up before being forced, and a lock stranded by an earlier crash is detected and recovered instead of stopping you.
• Large images make it through instead of failing Generated images bigger than the messaging layer’s payload limit were rejected in transit, so the work completed and then the result never arrived. Images are now chunked to fit, so a large one arrives the same as a small one.
• A workflow gets exactly the tools it declares Tool availability had drifted into several overlapping mechanisms, with the result that workflows which had moved off the old filter setting silently lost their tools entirely, and parameter bindings configured on a workflow or preset were not applied. Declared tools are now what a run receives — no more, no less — and tool grants are scoped to the run that earned them, failing closed rather than open.
• A stalled model response no longer cuts your turn short The existing safeguards watched for silence on the network, so they could not see a provider that had sent its data and then stopped producing anything meaningful. That shape ran until an outer deadline and truncated the turn with no explanation. Stalls are now caught where they happen, and a turn that hits a deadline is no longer lost.
• Skill suggestions no longer rewrite your message The suggester was appending its note onto the end of your last message, which meant the transcript no longer matched what you actually sent and the model saw you asking for things you never mentioned. Suggestions are now delivered as their own message, positioned so the model still reads them alongside your request — but your words stay yours.
• Daemons are identified by where they actually run A daemon is now keyed by its origin, account and workspace together, so separate workspaces no longer contend over the same identity. A daemon that comes up without credentials repairs itself rather than waiting, and a workspace that takes several minutes to provision is no longer reported as a failure.
• Sign-in helper opens only when it is needed The localhost helper used for provider sign-in now starts on demand over the existing daemon connection, and corrects itself if a previous attempt left it in a bad state — so a cancelled sign-in no longer blocks the next one.

​

The chat list stops rearranging itself, and new workspaces show up straight away

• The chat list no longer rearranges itself while you work The list arrived from the server ordered by whichever conversation was touched most recently, so activity in a chat you were not looking at could reorder the ones you were. Ordering is now decided entirely by the chats themselves, with ties broken consistently, so the list stays put unless something you care about actually changes.
• A workspace you create appears immediately Creating a workspace in a project with more than one repository saved it without telling the part of the app that tracks workspaces, so it was missing from every picker until you refreshed — and the selection would snap back to the main branch on its own. Unarchiving a chat had the same gap. Both now update the app’s view of your workspaces as soon as the change is made.
• A stalled provider now explains itself When a provider accepted a request and then went silent until the turn was cut, the message you saw ended in a bracketed internal code. That tail is now removed before the message is shown, leaving the readable explanation — which provider stalled, and that the turn is being retried.
• Release tags are now guaranteed to match what shipped Version tags were being created from whichever commit happened to be checked out, which could differ from the commit that actually landed. Tagging now targets the commit on the main branch and verifies it before publishing, so a released version always corresponds to the code that shipped.

​

Choosing a machine tells you what you get, buying credit is one screen, and running low no longer takes you by surprise

• Machine sizes now say what you are getting The sizes were named Small through XL with a price and nothing else, so choosing one meant guessing what was behind the name. Each option now states its memory and CPU — 4 GB RAM and 1 CPU for Medium, for instance — along with how far it can burst above that when a build needs the headroom. Memory and CPU stretch by different amounts, and the page says so separately rather than rounding both to one reassuring number.
• Running on your own computer is presented as a normal choice The option to use your own machine sat below a divider, after the paid sizes, which read as a footnote rather than an alternative. It now appears first, in the same list as everything else, with the instructions for connecting it directly beneath. Choosing it no longer scrolls you past a card you had already decided against.
• Buying credit happens on one screen Payment used to hand you off to a separate embedded checkout partway through, which meant the price you were agreeing to and the details you were entering lived on different screens. Both now sit together on a single card, so what you are buying stays visible while you pay for it.
• The service fee is shown before you pay A 5% service fee is added to credit purchases. It was previously only visible after the fact, including on automatic top-ups, where the amount charged and the amount credited quietly differed. Both figures are now shown at the point of purchase, on manual purchases and automatic ones alike.
• You are warned before your credit runs out Running out of credit was something you discovered by being stopped. The app now shows an indicator when your balance is within about a week of empty, based on how quickly you have been spending, and explains what has happened if you do reach zero rather than simply refusing to continue.
• Signed-out screens stop retrying in the background After signing out, parts of the app kept polling for data they were no longer allowed to fetch, producing a stream of failed requests behind an otherwise idle screen. Those requests now stop when the session does.
• The background command tools have consistent names The tools for running and managing background commands were named inconsistently — some after the shell they happened to use, others after what they do. They now share one naming scheme. Behaviour is unchanged; only the names differ.

​

Pinning a step to one tool works on every provider, and chats get real titles without an Anthropic account

• Forcing a step to use one specific tool now works on every provider A workflow step can require the assistant to use one particular tool rather than choosing freely. That instruction was only understood by some providers — on the others it was accepted and then silently ignored, so the same workflow behaved differently depending on which AI you had configured, with nothing to indicate why. Every supported provider now honours it. The instruction is also only applied when the named tool is genuinely available for that request, since asking for a tool that is not on offer is rejected outright by every provider.
• Chat titles no longer require an Anthropic account Titles are written by a small, fast model, and that step used to be tied to one specific model from one specific provider. If you had not connected that provider, titling could not run at all — and because the chat then fell back to showing the opening words of your first message, the result looked like a title rather than like a failure. Nobody had reason to report it. Titling now picks whichever fast model your own provider offers, so every chat gets a real title regardless of which AI you use.
• The guided tour after setup no longer loses its place When setup finished and the tour began, restoring your newly created project could arrive a moment later and wipe out the tour’s position, leaving it with no step to show and nothing on screen. Whether this happened came down to timing, which is why the tour appeared to work sometimes and silently not others. The tour’s place is now preserved across that handoff.
• Setting up for the first time is shorter and clearer The step that chooses where your work runs led with a large diagram that pushed the actual choices below the bottom of a normal window, so the illustration read as the interface. The question now comes first and the options are visible without scrolling. Wording throughout setup has been rewritten to describe what you get instead of naming internal machinery, and the starter cards on the workflow screen now lay themselves out based on the space actually available rather than the width of your whole window, so they no longer wrap to one word per line beside an open terminal.
• Editing a list of values no longer drops entries as you type Workflow fields that hold several values are typed as a comma-separated list. While you were mid-entry, the partially typed text could be read as empty and discard values you had already committed, or overwrite the separator you were in the middle of typing. What you type is now kept exactly as entered until you are done with the field.

​

A streaming hiccup no longer wedges a conversation for good

• A streaming glitch no longer wedges a conversation permanently Replies arrive in pieces, and occasionally a piece arrives malformed. That has always been a normal, momentary hiccup that we simply retry. A recent change to the underlying language runtime renamed one of the internal types involved, and because the check that recognised this situation was matching on that name, it quietly stopped matching. The hiccup was then treated as a permanent failure: the conversation stopped and could not be continued. The check now keys on a stable part of the message instead of a type name that shifts between runtime versions, so these glitches are retried again — and the fix will not silently come undone the next time that name changes.
• Signing in with Claude or Codex is clearer These sign-ins need something running on your own machine to hand control back to, which is not always available depending on how you are running Reliant. The app now works out whether that hand-back is possible before you begin, and shows a short panel telling you exactly what to run if a step is needed on your side, rather than sending you into a sign-in that cannot finish.
• Setting up for the first time is smoother The step that picks where your work runs has been rebuilt, and download options for the desktop app are now presented properly. Returning users who already have everything they need are recognised more reliably and taken straight to the app instead of being walked back through setup they already completed.
• The desktop app no longer vanishes on an unexpected error An unhandled error in the desktop app’s background process could take the whole app down with no explanation. Those errors are now caught and recorded, so the app stays open and there is a trace to explain what went wrong.
• Console messages are collected in one place Diagnostic output from the web interface and the desktop app now gets forwarded into the same log directory as everything else. When something goes wrong there is one place to look, and reporting a problem no longer means copying messages out of a developer console by hand.
• The development server opens on the right address When run through our tooling, the development server could bind a stale, previously configured address rather than the one it was actually assigned — so it appeared to start correctly while being unreachable, or collided with another instance. It now honours the address its launcher gives it. This affects people running Reliant from source, not the packaged app.

​

Signing in with Claude or Codex works in the browser, and the desktop app stops going blank

• Signing in with Claude or Codex now works outside the desktop app These sign-ins have to hand control back to something running on your own machine, which previously only the desktop app could do — in a browser the sign-in simply had nowhere to return to. There is now a small command you can run in a terminal that receives the hand-back, so the same sign-in completes in a browser. It only bridges that one step: your account details are still exchanged and stored by the server, never by the local helper.
• The packaged app no longer opens to an empty window The desktop app loaded its interface in a way that made every internal address resolve against your filesystem instead of the app itself, so nothing ever loaded and the window stayed blank. The failure was silent by construction — the page itself loaded fine, so no error appeared. The app now serves its own interface through a dedicated internal address, and the packaging step is checked so a build that would have shipped this cannot be released.
• A chat no longer stalls when the model returns nothing or declines If the model finished a turn without producing any text, or declined to answer, the conversation could be left waiting on a reply that was never coming. Those endings are now recognised as real endings, so the chat continues and you can send the next message. Long-running turns are also cancelled properly when you stop them, rather than continuing invisibly in the background.
• Your font-size preference now applies everywhere Parts of the interface were written with fixed text sizes, so they stayed the same no matter which font size you chose — enlarging the type to read them did nothing. Those places now scale with the rest of the app, and a check has been added so a fixed size cannot quietly reappear.
• The desktop app reconnects more reliably When the background service the app depends on restarted or dropped its connection, the app could be left showing a stale state. Restarts, disconnections and leftover processes from a previous run are now detected and reported, so the app recovers on its own instead of needing to be quit and reopened.

​

The app no longer goes blank when a setting is missing

• A missing setting no longer leaves you looking at a blank window One piece of configuration is read the moment the app starts. If it was absent, the code that reads it stopped the app before anything was drawn — so instead of an error you got an empty window, with the explanation only visible in a developer console most people never open. The app now starts regardless and only reports the problem if you reach a feature that genuinely needs that setting, where the message says which setting is missing. Nothing is invented to paper over it: a build that is missing the value still says so rather than quietly behaving as though it has one.
• Windows gets told about new versions on time After a release, the file the app checks to discover updates was being cleared for macOS and Linux but not for Windows, because the step that clears it named a file that does not exist. Windows users could keep being told they were up to date for up to a day after a new version shipped. The correct file is now cleared, and the release will stop and report if it is ever asked to clear something that is not there — the previous behaviour reported success while doing nothing.
• The end-to-end browser tests actually run The browser test suite had never passed. Every test was failing for the same reason described above — the app never started, so nothing could be tested — which meant the suite could not report on anything else either. With that fixed the full suite now runs and passes, so a real regression in the interface will be caught before it ships instead of being hidden behind a permanently red result.

​

Deployment plumbing, and a desktop build that runs everywhere it claims to

• The published container image runs on every architecture it advertises The image is built for both Intel and ARM, but the ARM build was linked against system libraries the image does not contain. Starting it failed with a message naming the program as missing — even though the program was there — because it was really the loader that was absent. The build now uses a toolchain that matches the image, and a check in the release pipeline reads the compiled program’s own requirements and refuses to publish an image that cannot start. That check exists because nothing before it could tell: the build succeeds, the image looks correct, and only running it fails.
• Releases reach production without manual steps The deployment pipeline had never once completed. It advanced through environments in order, but asking it for a single environment caused it to skip the ones before — and skipping those skipped the one you asked for. Production sat behind an environment whose cluster no longer exists, so it could never be reached at all. Deployments were being applied by hand as a result. It now deploys the environment you ask for, and pins every component to the exact build recorded for that release rather than assuming one label fits components built in different places.

​

Sign-in works again, and a stuck chat can no longer strand itself

• Signing in no longer lands on a black screen The packaged app began serving itself over an internal app:// address instead of a plain file path. Several checks around the app still tested for the old file path to decide “am I the desktop app?”, and every one of them silently answered no. Sign-in itself worked — the app just never rendered anything afterwards, with nothing in the console to explain it. Worse, the check that stops a local address being sent to an identity provider stopped recognising the app’s own origin. All of those checks now agree on what the packaged app looks like.
• The desktop app is built with the addresses it actually needs The released app was built from a hand-written list of settings that had drifted out of sync with the real ones. Eleven values the app reads were never supplied, so signing in with a coupon failed with “Control plane API URL not configured” and the gateway address was missing entirely. Those values now come from the same declaration the hosted web app uses, so the two cannot disagree, and the build fails outright if any of them is empty or points at localhost rather than shipping quietly broken.
• Signing in with Claude Code or Codex fails with a real explanation Both sign-in flows used a browser cryptography API without checking it existed. On a page served over plain HTTP — a tunnel or a phone on your network — that API is absent, so the flow died with Cannot read properties of undefined (reading 'digest') before anything useful happened. The flows now check first and tell you the page needs to be served over HTTPS, instead of failing with a message about an undefined property.
• A chat can no longer wedge itself permanently When a reply was interrupted, the agent recorded that a queued message was waiting even when none was. The conversation would then loop back for a message that did not exist, find the same reply still at the end, and fail — every time, forever. The chat could not be advanced again by any means. The agent now checks whether a message is genuinely queued rather than assuming one is, and a conversation that reaches this state recovers on its next turn instead of staying stuck.
• The stop button on background agents survives a refresh Background agents showed a stop button when they started and lost it after a page reload, which meant the long-running agents most worth stopping were the ones you could not stop. The identifier the button needs was only ever sent live and was missing from the data loaded on refresh. It is now recovered from records that already existed, so agents already running get their stop button back too.
• Files outside the current workspace can be opened Clicking a file path the assistant mentioned did nothing when the file sat outside the current workspace, with a tooltip saying it could not be opened. In the desktop app those files now open. Writes stay confined to the workspace, and a path that tries to climb out of its folder is still refused.

​

Three fixes to things that misbehaved quietly

• The “Some of your params have changed” message stays hidden Messages that exist only to give the model context are marked hidden and filtered out of the transcript. When one of those arrived as a live update rather than on a page load, the hidden marking was dropped along the way, so the message appeared in your chat until you reloaded — at which point it vanished, which made it look random. The marking now travels with live updates, so a hidden message is hidden the first time and stays that way.
• Non-streaming Claude Code requests no longer fail with a decoding error The Claude Code driver told the server it could accept brotli-compressed responses, but never actually decompressed them. Every non-streaming call therefore tried to read compressed bytes as JSON and failed with invalid character '\x03' looking for beginning of value. The driver now only advertises the compression formats it can genuinely handle, and decompresses the response before reading it.
• Chat titles retry instead of silently falling back to your first message If the model call that names a chat failed, the failure was swallowed and the chat was titled with a truncated copy of whatever you typed first. There was no retry and nothing in the logs, so a provider outage looked exactly like normal operation. The title request is now retried three times with backoff, and only falls back to your first message after those genuinely fail — and that fallback is recorded rather than invisible. Titles that come back empty are also rejected now, instead of being saved permanently.

​

Picks up the forge scaffolding fix

• Generated project code compiles without goimports installed forge generated a file with an import nothing used. It normally went unnoticed because forge runs goimports over its own output before checking it, and goimports quietly removes unused imports — so the mistake was harmless on machines that had that tool and fatal on machines that did not, which included our own build servers. The import is gone at the source, so the generated code is now correct as written rather than only after a formatter that forge does not install.
• The toolchain reports its real version forge now reads its version from a file committed alongside the code, instead of depending entirely on a value stamped in at build time. A build made from source used to report itself as “dev” and could not say what it actually was.

​

Windows builds again

• The Windows installer is published again the v1.7.2 build failed on Windows only. The step that loads the release endpoints is written in shell, and the Windows runner defaults to PowerShell, where those commands do not exist — it reported success while setting nothing, so the build stopped a few steps later when the configuration turned out to be empty. It now runs under bash on every platform. Nothing about the application changed.
• Everything from v1.7.2 the app can reach the backend again: it had been built pointing at a hostname that does not exist, and derived a second one that also does not exist. Sign-in and setup no longer stall waiting on a terminal the packaged app does not have. Billing and environments settings were reworked, and chat navigation gained keyboard shortcuts.

​

The desktop app can reach the backend again

• The app was pointed at a domain that does not exist every build since the endpoint was last changed shipped with api.reliant.so compiled in — a hostname with no DNS record at all. Nothing could connect, on any machine. It survived because the value lived in a GitHub secret, and a secret cannot be read back, diffed, or reviewed; the existing guard only checked the URL was non-empty and not localhost, and a dead domain passes both. These are public hostnames that ship inside the app, so they now live in a version-controlled file where a change is a reviewable diff.
• The daemon gateway address was derived incorrectly for production the gateway host is worked out from the API host, and the rule assumed the leading part of the name is an environment label — correct for preprod, which becomes gateway-preprod. Production is named for the service instead, so the rule produced gateway-api.reliantapi.com, which also does not exist. Production was the one environment the derivation got wrong, and production is what ships.
• A release now refuses to publish an unreachable endpoint before any platform builds, each endpoint is checked for four things: that it is set, that it is not localhost, that its DNS resolves, and that it answers over HTTPS. The first two were already checked and neither would have caught this. The build now fails in about ten seconds instead of producing signed artifacts that were never going to work.
• Sign-in and setup no longer stall without a terminal several daemon and sign-in paths assumed they could prompt at a terminal. The packaged app has none, so those flows waited on input that could never arrive instead of reporting the problem. They now handle the non-interactive case explicitly, and the app waits for credentials to be ready rather than racing them.
• Billing and environments settings, and chat navigation shortcuts the cloud billing and environments screens have been reworked, along with the compute step in setup and the connect-machine dialog. Chat navigation gains keyboard shortcuts, with the shortcut list and its documentation generated from one source so they cannot disagree.

​

A maintenance build with the v1.7.0 fixes

• Same application as v1.7.0 every user-facing fix in this build shipped in v1.7.0: the packaged desktop app loading at all, OAuth no longer redirecting to a local address, onboarding no longer ejecting you mid-setup, settings and sign-out reachable without a working machine, onboarding state no longer leaking between accounts, and cloud machines no longer able to run unfunded. Nothing in the application changed between v1.7.0 and v1.7.1.
• The release pipeline can publish again the image build had been failing on every push for over a week, which meant no new container image was published and deployments were pinned to a stale build. The causes were entirely in the build system — a private image registry that CI never authenticated to, credentials pointing at a workload-identity pool that did not resolve, a binary the container expected but nothing produced, and a tool installed to a directory nothing read. This build is the first to complete that pipeline end to end.
• The end-to-end test suite reports real results the browser test job had been hitting its time limit and being cancelled before it could report, so it had never once passed. It now completes in well under a minute rather than timing out at fifteen, and the onboarding tests were rewritten against the current sign-in and setup flow instead of a step that no longer exists.

​

The desktop app loads, and sign-in stops sending you to nowhere

• The packaged desktop app actually loads the renderer’s JavaScript was never fetched. The bundle asks for /assets/… and the app loaded its page from the filesystem, where a root-absolute path resolves against the filesystem root rather than the app — so the window came up blank. It was invisible by construction: the page itself loaded fine, so every success signal fired. The renderer is now served over an app:// scheme, which also lets deep routes survive a reload. This had been broken since v1.4.1.
• OAuth no longer redirects to a local address sign-in sometimes came back to http://127.0.0.1:<random-port>/auth/callback. The desktop app was handing providers its own local origin, because the method meant to supply the real one was declared in the type definitions and never implemented — so the fallback ran every time. A browser at localhost keeps its origin, as web development requires; only the desktop app substitutes the hosted URL.
• Onboarding no longer ejects you mid-setup choosing a cloud machine navigated away from onboarding before the “still starting” screen could render, dropping the user into the project picker with setup marked complete and no machine. The picker is what showed the daemon list people mistook for a second onboarding flow.
• Settings and sign-out are reachable without a working machine the only link to settings lived in a sidebar that renders inside the main app shell, which needs a selected project, which needs a machine. A user whose machine failed to provision could not open settings or even log out. The header now carries a settings control on the picker, and onboarding has its own settings and sign-out row.
• Signing out no longer leaks onboarding state to the next account the checklist mirrored itself to device-wide storage that sign-out never cleared, so the second account on a machine inherited the first account’s progress — which is how the API-key dialog could appear over a new user’s onboarding.
• Cloud machines cannot run unfunded resuming a suspended machine did not re-check compute funding, and the background reconciler would republish a machine every five minutes with no funding check at all, racing the enforcement sweeper. Resume now refuses when funding cannot be confirmed; the reconciler suspends instead of resurrecting, and deliberately allows the machine through when the funding lookup itself errors so a database blip cannot suspend paying customers.
• Production CLI commands are copy-pasteable again the web UI printed every CLI command behind five environment-variable overrides, including the auth key, for a binary that already has all of those values compiled in. Production now shows the bare command.
• Per-provider sign-in feedback clicking Google also showed GitHub as connecting, since one shared flag drove every button. Each provider now tracks its own pending state, and the sign-in request no longer times out at ten seconds while the user is still on the provider’s consent screen.

​

The binary reports its real version

• reliant version reports the released version the command read Version/Commit/BuildDate from its own package, but every build path injects internal/version instead — so those variables were never written and every released binary reported dev and unknown. The command now reads the package that is actually injected, and a test pins it so the two cannot drift apart again.
• The forge contract lint is clean 168 exportedvars and requirecontract findings are resolved. The genuinely link-injected variables in internal/builddefaults and internal/version keep their package-var form with an explanatory exclusion, because converting them to getters would silently break the -X injection the release depends on.
• A live-network test no longer fails CI TestWebSearchTool queried live DuckDuckGo behind only a short-mode skip, so it ran on every pull request and failed on bot challenges for reasons unrelated to the change under test. It now needs the same explicit opt-in as its sibling.

​

Packaged builds reach the hosted backend again

• The desktop app connects to the hosted backend the release pipeline never injected the hosted endpoint into packaged Electron builds, so the daemon was aimed at localhost:8080 and had nothing to talk to. The build-time config generator wrote analytics and auth keys but no server URL at all, on all three platforms.
• The released binary carries its hosted defaults the same defect on the Go side: internal/builddefaults is documented as injected via linker flags for released builds, but the release step set only the version and build type, so the shipped binary fell back to the same localhost default.
• A release that would ship the wrong endpoint now fails an empty or localhost server URL fails the release build instead of producing an artifact that points at nothing. The original bug was silent — a localhost default is correct when building from source and useless in a released artifact, and nothing distinguished the two.

​

npm license gate and two CI reliability fixes

• npm dependency licenses are gated in CI the npm half of the license gate now runs beside the Go one, on the same allowlist-not-blocklist bar — an unrecognized license fails rather than passing quietly. The web tree passes with 205 production dependencies checked.
• The websearch demo no longer fails CI on bot challenges TestWebSearchDemo queries live DuckDuckGo, which answers a share of automated requests with a challenge response. It is now behind an explicit opt-in instead of running by default, so a full CI pass no longer fails on an upstream rate limit.
• e2e harness documents why its daemon router is nil the story harness passes a nil daemonRouter deliberately — it is only used by the greenfield code-presence probe, which skips itself when nil. That is now stated at the call site rather than left to be rediscovered.

​

Async spawn, workflow lifecycle, and interruptible turns

• Async spawn and the runs service spawned work is tracked through a dedicated internal/runs service and a workflow lifecycle package, replacing the ad-hoc bookkeeping that made a spawn’s state hard to reason about once it outlived the turn that started it.
• Interrupt and pause handling a turn can now be interrupted or paused mid-tool and resumed, with the cancel and terminate paths split so stopping a run and tearing it down are no longer the same operation.
• Workflow state and stop reasons recorded new migrations persist workflow state and why a run stopped, restore workflow checkpoints, and scope update-stream counters, with added indexes on the hot write path.
• Generated code is committed a fresh clone or new worktree now compiles without running codegen first. The sqlc output, proto stubs, and docgen artifacts were previously gitignored, so every new checkout started broken and generator changes produced no reviewable diff.
• Temporal SDK 1.47 and forge v0.1.0 moves to Temporal SDK v1.47.0 with api v1.63.4, and forge v0.1.0 for the scaffold-stub sentinel and target-scoped env up.
• Dev chain teardown that works the Electron dev chain is supervised by a real process that owns its process group, so a scripted SIGTERM tears the whole chain down instead of leaving orphaned processes holding their ports.

​

Agent messaging, thread lifecycle repair, and a hardened release pipeline

• Agent messaging and spawn lifecycle with an agent message mailbox, queued composer input so a message typed mid-run is delivered rather than dropped, and parent threads woken when a sub-agent reports back.
• Thread identity recorded, not inferred threads now store how they were created, so a spawned sub-agent is never mistaken for a graph-node thread — a class of bug that previously made spawn threads render inline.
• Thread lifecycle and workflow history repair including reduced workflow history retention, a recorded verdict for each run so failures stop being reported as successes, and fixes to loop execution and transition handling.
• Daemon reliability and workspace management with a daemon reliability overhaul, worktree auto-init and adopt, more models, and more reliable workspace handling.
• Workflow preview delivery and CEL hardening covering preview forwarding, workflow simplification with transition_to, and hardening of CEL compilation.
• Release and build fixes the web build now type-checks again after 20 accumulated errors, the desktop release builds all three platforms including Windows, and the timestamp migration no longer fails on managed Postgres that owns views in the public schema.

​

Workflow routing, faster loads, and stronger distributed reliability

• Smarter workflow building with the new router node for choosing between multiple workflows, support for parallel loops, surfaced presets in custom workflows, and better context retention during iterative flows.
• Faster startup and streaming performance by reducing what loads on initial app open, scoping streamed updates more efficiently, and improving provider retry behavior for OpenRouter.
• Stronger distributed and remote daemon reliability with better remote daemon behavior, MCP requests correctly routed through the daemon boundary in distributed mode, and daemon heartbeat updates pushed more reliably over gRPC.
• Auth and security improvements including JWT validation hardening, CORS improvements, fixes for Google login and OAuth callback/timeout issues, and better reliability for Claude subscription login flows.
• Bug fixes across workflows, MCP, and web including fixes for loop execution and CEL compilation on first iteration, workflow loading in web, MCP reliability, empty task handling, message saving in loops, thread state, tip display, and general validation and SQL query issues.

​

First open source release, onboarding polish, and split architecture support

• First open source release with the new public release flow, packaging updates, and release process improvements.
• Better onboarding tips with clearer setup guidance, improved post-onboarding prompts, and less eager tip display.
• Remote daemons and split architecture support with stronger support for distributed deployments, full daemon flows, and the new single-binary backend command architecture.
• More telemetry and diagnostics with improved telemetry, error reporting, and better signal quality for production debugging.
• Bug fixes and reliability improvements including migration fixes, auth fixes, MCP listing fixes, workspace restore fixes, and UI polish across settings and diff tabs.

​

DNS resolution fix, GPT-5.4 Mini support, and parameter editing improvements

• Fix DNS resolution fix scenarios where DNS resolution might be broken.
• Improve error message UI error messages are now displayed more clearly.
• Fix non-string parameter editing resolve issues when editing non-string parameters.
• Add GPT-5.4 Mini support add support for the GPT-5.4 Mini model across Reliant workflows and model selection.

​

Claude Code OAuth, isolated env setup, and per-thread plans

• Claude Code OAuth support so you can connect Claude Code without manual token setup.
• New env-setup workflow for isolated ephemeral environments that work cleanly with git worktrees.
• Plans are now scoped per thread for clearer agent coordination and better agentic workflows.
• Workflow and worktree reliability improvements including fixes for preset loading, custom preset tools, and workflow/worktree execution edge cases.

​

New models, workflow reliability, yield controls, and performance improvements

• More reliable workflow execution with improved pause, resume, replay, and thread-state handling.
• New yield controls for better responsiveness and execution control.
• Faster, smoother experience across runtime and UI.
• Workflow builder polish including clearer tool diff rendering and loop-node improvements.
• Model and reasoning updates:
  • Claude 4.6 Sonnet
  • GPT-5.4, GPT-5.4 Pro, and GPT-5.3 Codex Spark
  • Gemini 3.1 Pro
  • xhigh thinking support
• MCP improvements including better reliability and HTTP MCP support.

​

New models, tray menu, and reliability improvements

• Model updates:
  • Claude Opus 4.6
  • GPT-5.3 Codex
  • Local models support
• Added a tray menu for faster access to chats, workspaces, workflows, notifications, and app actions.
• General bug fixes and usability improvements.

​

Bug fixes and improvements

• Fixed token counting for Gemini.
• Fixed workflow builder UI dropping data.
• Added more workflow builder guardrails and adjusted tools.
• Improved workflow hub and workflow naming.

​

Initial release

​

Highlights

• Chat interface with full codebase context
• Programmable workflows in YAML
• Multi-agent patterns including debate and parallel execution
• Built-in presets for research, testing, debugging, and more
• Git worktrees for isolated parallel work

​

Execution control

• Auto, Manual, and Plan modes
• Pause and resume with state preservation
• Live parameter updates during execution
• Automatic pause on failure

​

Platform support

• macOS via Homebrew or DMG
• Windows via EXE installer
• Linux via AppImage