Inyon releases

Inyon 0.17.5

2026-10-16T11:47:03Z

Two fixes for updating.

A hub from a git checkout updates again. Its git fetch --tags refused to move the node-latest and android-latest tags that every build re-points, exited non-zero, and the hub reported a network problem. The fetch is forced now, in the update and in the hourly check. A hub on an older version needs one manual git fetch --force --tags in its checkout before it can pull this.
Agents are updated where they live. An agent installed with npm into a folder of its own (an older Inyon kept OpenCode under ~/.local/share/tether-tools, with ~/.local/bin pointing into it) was updated with npm install -g, which put a second copy where the PATH never looks. The Setup tab now knows the folder and updates the copy there.

Inyon 0.17.4

2026-10-16T10:48:45Z

Agents you can install and update from the app, background agents that show as work, and the fixes from a full review of the code.

Install and update agents

A machine's Setup tab shows each agent's version against the newest one on npm, with Update to X when it's behind, and Install for any of the six that's missing (Claude Code, Codex, OpenCode, Copilot, Gemini CLI, Antigravity). From the browser or the phone.
Update runs npm for an npm install, otherwise the agent's own updater (claude update, codex update, opencode upgrade, copilot update, agy update), or its installer again.
When a step fails, the row opens with the likely cause, the last lines it printed, the command to run on the machine yourself with a copy button, and the install guide.

Background agents

A Claude Code session whose turn ended with subagents or shells still running shows as Background with what's running (1 shell and 1 agent running in the background) instead of Idle, the home status line no longer says All quiet while they run, and the Finished alert waits until they're done.

Typed pairing codes

The record a computer publishes for a typed ID is now keyed by the ID and the 6-digit code together, so knowing the ID alone doesn't let anyone stand in for the computer. Typing a code needs the app and the computer both on 0.17.4 or newer; the QR code and the link work across versions.

Fixes

Windows: live terminal output reached the hub again (the engine's pane rewrite had stopped matching the hub's attach command since the locale change in 0.17.0), so sessions on a Windows machine update as they print instead of at the next poll.
The hub prunes earlier engine builds again; the link survives the hook log being rotated; removing a server takes the phone's key out of authorized_keys even when the file has no final newline, and adding one never glues it onto the last line.
The plain-http exception for private addresses only accepts a whole address, not a name that starts like one; uninstall never signals a pid that can't be one; a bad Content-Length can't abort the updater; a blank line in SHA256SUMS doesn't hide the entries after it; clicking "← back" in the setup wizard goes back instead of on; the Windows migration link is a junction; ts.net is matched on a dot boundary.
Messages arriving in pieces are capped; machine ids must be canonical; address records keep a monotonic seq across clock steps; busybox is checked against the hub's pin on Windows.
Android: deleting a server with a login still in progress no longer waits up to 42 seconds; two notifications can't open each other's session; the keep-alive wake lock can't outlive its service.
Chat watchers clear every timer when they stop; the password check reads one record; the task sheet says 3 seconds like its timer; \ No newline at end of file no longer counts against a diff's line budget.

Inyon 0.17.3

2026-10-14T19:23:06Z

A window on Windows, and no more windows flashing.

The Inyon window (Windows)

Open Inyon and Pair a phone… in the tray menu open a small window of Inyon's own instead of a terminal: whether it runs, where it answers, which phones are paired, and the same four actions as buttons. Drawn in Inyon's style, sharp at any screen scale, and it refreshes every two seconds without flickering.
The pairing code is a picture. The QR code to scan sits on its own card, with the code to type beside it. Opened with no phone paired yet, the window shows a code straight away.
Behind it, inyon window link and inyon window link --pair open it from anywhere; a second start brings the open window to the front. What it does goes to ~/.inyon/node/window.log.

No more flashing

Everything the engine starts on Windows (psmux, PowerShell, the shell) runs hidden, whichever part of the program starts it. Before, a notification's title lookup opened a console window for a moment.
Asking for a pairing code from the window no longer opens a console for the engine either.

Inyon 0.17.2

2026-10-14T18:19:37Z

Fixes from the first day of real use on a Windows laptop, mostly around what happens after setup.

Windows

The phone no longer loses the computer. inyon pair didn't see the link already running in the background and started a second one. That one published its own address, and when it ended with the terminal the phone was left pointing at a dead tunnel: pairing worked once, then the computer was unreachable. A link is now also recognised by what answers on its port, so pair and link reuse the one that runs.
The tray menu works. Open Inyon and Pair a phone… opened a window that closed at once. They open a terminal window of their own now.
inyon is found by name. Setup puts ~\.inyon\bin on your user Path when it isn't there, not only the installer, so a copy that got there another way, or a setup run after an uninstall, works in new windows too.
Inyon is in Settings → Apps. Setup lists it there with its version, inyon update keeps the version current, and Uninstall there runs inyon uninstall --purge in a window that stays open until you press Enter.
Uninstall finishes the job. It checks that the logon task is really gone and says so if not. ~/.inyon is removed one entry at a time, so a file an agent's hook still has open no longer keeps everything else behind.

Setup and uninstall

Setup installs tmux. When tmux (psmux on Windows) is missing, setup asks and installs it: winget or cargo on Windows, Homebrew on macOS, your package manager through sudo on Linux. --yes doesn't ask.
Uninstall asks before removing it. Only when setup installed it; the default is to keep it, and inyon uninstall --yes keeps it without asking. tmux that was there before Inyon is never touched.

The terminal

The Inyon mark's line hangs from the kite in every font instead of floating beside it.
When you quit the inyon dashboard, what it showed is printed as plain lines, so your terminal's history keeps both what was there before and the status you looked at.

Inyon 0.17.1

2026-10-14T14:40:23Z

Fixes from a full test on a Windows 10 laptop, an Android phone and an Android tablet: installed from scratch, paired, used for real work, updated and uninstalled.

Windows

No window at sign-in, and a tray icon. Inyon now starts in the background without flashing a console, and shows an icon in the notification area while it runs: Open Inyon, Pair a phone…, Show the log, Restart and Quit Inyon. On Windows 10 it may sit under the ^ arrow at first.
The firewall lets phones in. When you tick LAN or VPN in setup, it adds a rule named "Inyon link" (Windows asks an administrator once). It lets in only the link's port, only to inyon-engine.exe, and only from the local network and VPN ranges. Before, Windows counted VPNs as public networks and phones couldn't connect over them.
Live status for every session. psmux names a pane %1 in every session, so two Claude Code sessions on one Windows machine shared their status files and the app showed neither one's model, context or limits. Each session keeps its own now. Inyon updates the integration's scripts on the machine by itself.
inyon uninstall --purge removes everything. It stops the engine, the tunnel and the tray first, deletes inyon.exe once it has exited, takes ~\.inyon\bin off your Path and removes the firewall rule. It lists anything it couldn't delete.
inyon logs shows the link's log on Windows too.
Over SSH, inyon setup and inyon doctor find psmux and the agents on your user Path.

Install and setup

inyon is on your PATH after get.sh or get.ps1, in new terminals. Set INYON_NO_MODIFY_PATH=1 to keep the installers from touching it.
Setup keeps what you ticked. Pressing Enter on the network screen no longer unticks the box under the cursor, and the summary lists every VPN it found.
Readable names and local times. The dashboard and inyon status show a phone as "A142" instead of "A142 Build/BP2A.250605…" (phones paired from now on as "Nothing A142"), and times in your time zone.

The app

A model or effort you pick stays in that session. Claude Code saves a /model or /effort pick as your default for new sessions; Inyon now puts model, effortLevel and modelSettings in ~/.claude/settings.json back the way they were.
Prompts read cleanly. Commands lose the │ border from Claude's screen, lines stay apart, edit diffs are in colour, and an edit's alert names the file.
Status keeps up. A session shows Working as soon as you answer it, "Active … ago" counts from the last activity, and Recent activity stops saying "needs you" once you've answered.
Reconnecting is calmer. The last question stays on screen while the app reconnects, with "Reconnecting to …" instead of "offline".
Phones and tablets. Notifications are asked for after you add your first computer. On tablets the sidebar sits below the status bar and keyboard hints are hidden on touch screens, and the keyboard closes after Send. The jump-to-bottom button no longer covers text, and a computer's name isn't cut off on a phone.
Smaller things. The effort chip shows the model's default level instead of "Default". A computer's probe time reads "responds in 1.4 s". Windows folders show properly in folder chips. The terminal draws ⏵⏵ and other symbols, with a minimum contrast for faint text. Removing a computer and pairing it again no longer shows the old entry's error.

Docs

New notes on Play Protect's scan prompt, on an npm global folder that isn't on your PATH, on the Windows firewall rule and on how the integration updates itself.

Inyon 0.17.0

2026-10-14T08:23:21Z

Review what an agent did without leaving the app, a right-click menu everywhere, and machines that stay clean when you're done with them.

Review the work

Files. The side panel (and Activity on a phone) has a Files tab: the session's folder, read only. Read code with syntax highlighting, Markdown rendered, and images. Mention puts @path in your message.
Working tree. Changes now has two views. This chat is what the agent edited in this conversation, as before. Working tree is what git sees: every change since the last commit, whoever made it, with the branch and how far it is from its upstream. Commit all and Push are there too, and your git hooks and signing run as usual.
Comment on a diff. Tap a line number in any diff to leave a comment. Comments collect under the diff, and Add to message puts them all in your message box as one review, so you can add to it before sending.
Fork a conversation. Fork conversation in the session menu (Fork on a phone) opens a copy of a Claude Code, Codex or OpenCode conversation in a new tmux window, in the same folder and with the same flags. The two carry on separately, so you can try something else without losing where you were.

Right-click

Every part of the app now has its own right-click menu instead of the browser's: text boxes get Cut, Copy, Paste and Select all, links get Open and Copy link, files and changed files get Mention and Copy path, and anywhere else gets Back, Reload, Search… and New session…. Hold Shift for the browser's own menu. How Inyon works in Settings now opens the docs instead of GitHub.

Cleaning up after itself

Uploads never pile up. The hub tidies every machine about every six hours and when one comes back online. It deletes uploads past their age, then the oldest ones while the folder is over the new Keep at most setting (1 GB by default). A file whose upload broke off keeps a .part ending, so an agent never reads half a file, and goes after an hour. A computer paired only with a phone tidies its own uploads the same way.
Removing a machine takes Inyon off it. While it can still be reached, removing a machine takes back the Claude Code and Antigravity integration (your own status line comes back), the uploads, the prompt log and the hub's SSH connection. Removing a server you reached with the phone key takes that key out of its authorized_keys, and removing a paired computer unpairs the phone on it too.
Secrets are private from the first byte. Files that hold settings, pasted prompts or a token are written readable only by you, and a temporary copy is removed even if the write is cut off.
inyon uninstall --purge gives Claude Code and Antigravity their own status lines back and drops Inyon's hooks before deleting ~/.inyon, and removes folders older versions left behind.

Inyon 0.16.1

2026-10-14T06:57:32Z

A terminal fix for high-resolution screens, a Support link, and a README for people who haven't used Inyon yet.

The terminal no longer shows a few giant lines. With WebGL at a 2x pixel ratio, some browsers sized the terminal's canvas in CSS pixels once it refit, so every character came out twice as big and only the last lines fit. The terminal now checks the canvas right after WebGL takes over and goes back to ordinary page drawing if it's at the wrong scale. Settings → About → Terminal drawing says which one is in use.
Support Inyon in Settings → About opens GitHub Sponsors in a new tab. Inyon is free and MIT licensed, so this is only for people who want to chip in. The README has a short Support section too.
Why not Paseo, Happy or Claude Remote Control? The README now says how Inyon differs: it picks up agents already running in your tmux panes, needs only tmux and your agents on a server reached over SSH, and signs in to nothing. It also says what you give up: there's no iPhone app yet, and a new agent release can break a reader until Inyon catches up.
README pictures redone from the current app, so they show the 0.16 shortcuts (Alt N, Ctrl K) and the terminal as it should look.

The README's recordings come from a script that drives the real app (apps/web/scripts/readme/shots.ts). On some ARM servers Chrome crashes or hangs after about a hundred captures; the script now starts a fresh browser and carries on from the same frame.

Inyon 0.16.0

2026-10-13T21:10:25Z

Right-click menus, a removed machine that stays removed, and a calmer refresh.

Right-click menus. Sessions, machines, your messages, the agent's replies, code blocks, the terminal and past conversations now have a menu where you right-click. A session or a machine offers the same actions wherever it's listed: in a card, the sidebar, the overview or a machine's page. The ⋯ menus use the same lists, so a session card's menu also has Rename…, Past conversations…, Copy session ID and Open in new tab. With text selected, Copy comes first. Text boxes, links to other sites and Shift+right-click keep the browser's own menu. On a phone, long-press a row in the sidebar, a machine or a past conversation for the same menu.
A removed machine stays removed. Removing a machine closed its connection, but its background service started inyon again, and it called the hub every 30 seconds for good. Now it leaves the hub by itself, as inyon disconnect would: it forgets the hub and removes its service. A machine that was off at the time does this the next time it starts. The hub tells a removed machine apart from one whose token it simply doesn't know, so a hub that lost its data doesn't make machines leave. On a machine removed before 0.16, run inyon disconnect.
New session from anywhere: Alt N (⌥ N on a Mac). N alone only works while you aren't typing, and in a session the message box takes the key. Alt N works from the message box too, but not in the terminal, where Alt keys belong to the shell. The sidebar shows each shortcut the way your computer names its keys.
Pull to refresh no longer spins the logo. As you pull, the kite's line pays out from the node; while the page refreshes, it reels in and out. The refresh button on a computer does the same.

Checked: the hub answers a removed machine's token differently from an unknown one, a removed machine runs inyon disconnect and stops, disconnect stops the service only after everything else is gone, and a systemd user unit that removes itself that way isn't started again.

Inyon 0.15.0

2026-10-13T20:10:23Z

Go back to an earlier conversation from the app, and use Inyon on a tablet.

Past conversations. Each agent's resume picker only works in its terminal, so Inyon now lists an agent's saved conversations for the session's folder and switches to one. Open it with Past conversations… in the ⋯ menu, History in the phone's controls sheet, the panel shown when no agent is running, or by sending /resume (/switch in Copilot and Antigravity, /sessions in OpenCode). The agent exits the way /exit would and starts again on the conversation you picked, in the same pane. Works for Claude Code, Codex, GitHub Copilot, OpenCode and Antigravity CLI; Gemini CLI isn't supported yet. A paired hub needs 0.15 too.
Phones stay upright, tablets turn. The Android app no longer rotates on a phone. A tablet, or a foldable when it's open, turns with the device and gets the wide layout.
Tablet layouts. The machines table and the message box's controls now fit the space they have, not the screen's width, so they no longer squeeze next to the sidebar. Cards no longer glide across the list when only its width changed.
A terminal draft shows up after the terminal view. Text typed in the terminal while the terminal view was open now appears in the message box when you switch back.
Attachments show their own name without the upload prefix, with an image or file icon to match.
Paired hubs stay current on the phone. A hub's new name or version shows up without pairing it again.
Machines with the same name are told apart. The second one, if it comes through a paired hub, shows that hub's address after its name.

Checked on an Android phone against a test hub: listing, switching while the agent runs, /resume from the message box, starting a past conversation after the agent exited, and the portrait lock. Tablet layouts were checked at 600 to 1280 pixels wide.

Inyon 0.14.1

2026-10-13T17:46:07Z

Downloads and updates come from the website.

Installs and updates use the website. get.sh, get.ps1, inyon update and setup's engine download now fetch from https://inyon.abhashchakraborty.tech/download, which keeps a copy of the newest release. Every release stays on GitHub too, and INYON_DOWNLOAD still points anywhere else. This version is the first to update from the website; 0.14.0 and earlier update from GitHub.
The website's version list can't swap a release. The website names its release in latest.json, which isn't signed, so it only chooses what to fetch. After SHA256SUMS.minisig checks out, the signed list must name inyon-<version>.apk for that same version, or nothing changes.
A signing key from the environment counts only for a test release. INYON_SIGNING_KEY is ignored when downloads come from the website or from GitHub.
No gzip, still installs. If the website serves only the .gz copies of a large release, get.sh on a machine without gzip takes the plain file from the matching GitHub release and checks it against the same signed list.
Update checks read the website. The hub, the app's check for your computers and the Android app read latest.json instead of GitHub's API, and the Android app downloads its APK from the website.
The website shows a release only once it's complete. It waits until the APK is in the signed checksum list, so the download page never links a missing APK. 0.14.0's page had that problem for a few minutes after it came out.

Checked in containers: an older command updated itself from the website, setup fetched the engine with GitHub blocked, a copy whose latest.json named the wrong version was refused, and Ubuntu (with and without gzip) and Alpine installed from the website.

Inyon 0.14.0

2026-10-13T16:56:19Z

Signed downloads, Alpine, and one owner for services and updates.

Every release is signed. SHA256SUMS comes with SHA256SUMS.minisig, a minisign signature by Inyon's release key (RWRTvQv/ifQnD3jarY1oarS0AKdhogH+mdgn/o0NzT/Ro8L43nFqqfp6). inyon update and setup's engine download check the signature before trusting the list, and refuse a release that lacks it or fails it; nothing on the machine changes in that case. The installers check it too when minisign is installed, and say so when it is not. How to check by hand is on the security page.
Alpine runs the engine. The release carries inyon-engine-linux-x64-musl and inyon-engine-linux-arm64-musl, and the command picks them on a musl system. The engine needs libstdc++ and libgcc there; the installer adds them as root, or says how. Checked with a full install in an Alpine container.
The command owns services and updates. The engine no longer installs background services or updates itself; inyon setup, inyon service, inyon join, inyon hub and inyon update do all of it, as they did since 0.13, and the engine is only the program that runs the link, the hub connection and the hub. Updates started from the app work as before.
Downloads from the website. The latest release is mirrored at https://inyon.abhashchakraborty.tech/download/, and the docs now live on the same site. The mirror only takes a release whose signature and checksums all check out.
Hub sessions work from the phone again. The app streamed request bodies to a paired hub, and Android's WebView sends a streamed body only over HTTP/2, so messages, goals, models, attachments and sign-in all failed on a hub's machines. Bodies now go as bytes. Reconnecting no longer opens a second connection to the same hub, and a message that fails after a reconnect is resent once, then waits for Retry.
Ending an agent's session no longer waits out the timeout when the hub never saw the agent's process. tmux answers success for a pane that is gone, so the hub now checks the pane's id instead.
The tether-node-* copies of the engine are no longer attached, as 0.13's notes said. A machine still on 0.10 or earlier installs again with the one-line installer.
Windows on ARM keeps the arm64 command with the x64 engine: there is no Bun build for it yet. A hub hands its machines the glibc engine; an Alpine machine installs from the release instead.

Inyon 0.13.3

2026-10-13T15:46:53Z

The Android app can pair with a hub on a plain address.

Hubs on a private network. A hub reached as http://<name> or http://<ip>:4777 (a LAN, Tailscale, NetBird) could not be paired from the Android app: Android blocks plain http from an app unless the app says otherwise, so the request failed on the phone with "Failed to fetch" before it reached the hub. The app now allows it. Hubs behind a tunnel or a domain were never affected.
A better message when a hub doesn't answer. A timeout asks whether the phone is on the hub's network; a plain address typed into the web app explains that the Android app, or the hub's own page, is the way in; anything else asks whether the address opens in the phone's browser.

Update the app from the release's APK, then pair again from Add → Connect to a hub.

Inyon 0.13.2

2026-10-13T14:51:27Z

The opening animation, made dependable.

It waits for the header. On a first open the page can still be signing in when the mark has finished drawing. The mark now holds for up to a second until the header is there, then flies onto it. Where no header turns up it fades in place.
It always flies the whole way. About one cold start in four lost the flight: the browser dated the move from the last frame it had painted and declared it over almost at once, so the mark seemed to jump and the page cut in around it. The flight now starts inside a rendering frame, and the opening only ends once the mark really sits on the header's mark. Eighteen cold starts in a row land to the pixel, phone and desktop, light and dark.

Inyon 0.13.1

2026-10-13T14:28:37Z

A short intro on a cold start, and the mark's line put to work.

Opening. The first time the app opens in a session, the mark draws itself: the computer drops in, a light trails behind it and draws the line, and the kite is where it lands. Under 1.2 s, then it flies onto the mark in the header and the page fades in behind it. It measures where the header's mark is, so it lands on it exactly, and the page is only handed over once it has arrived. A tap skips it. With reduced motion on, nothing moves: the finished mark shows for a moment and fades.
The same line, waiting. The empty overview and the pairing wait use the drawn mark instead of a spinner, so the first screen and the first pairing look like the same product.
The page's ground colour is set before any stylesheet loads, so a cold start in dark mode no longer flashes white.

Inyon 0.13.0

2026-10-13T13:57:37Z

A new inyon command, in beta. Set up a computer: curl -fsSL https://inyon.abhashchakraborty.tech/get.sh | sh (Windows, in PowerShell: irm https://inyon.abhashchakraborty.tech/get.ps1 | iex).

inyon is a 2 MB program now. It answers in a few milliseconds, draws the setup questions and a status dashboard in the terminal, and owns what the machine runs in the background. Today's program ships behind it as the engine (inyon-engine, fetched by setup with a progress line) and keeps running the link, the hub connection and the hub.
Setup asks four things: what this machine is to the app (paired to the phone, a hub, or joining a hub), how it answers (this machine only, the LAN, a private network it finds, the tunnel, or your own address), whether to run in the background, and for a hub the web sign-in. Then the pairing code. Without a terminal, or with --yes, flags answer the same questions.
Commands: inyon (the dashboard), setup, pair, phones, forget, join, disconnect, hub start|stop|restart, service install|uninstall|status, logs, doctor, update, uninstall, version. Each takes --json.
Existing machines cross over by themselves. An install from 0.11 or 0.12 updates to both files and keeps its pairings; one that cannot prints the one-line reinstall. Services written by earlier versions keep working. Update a hub before the machines joined to it.
A hub hands the whole thing to machines it adds, so a machine without GitHub access still installs, and the dashboard on a hub lists its machines.
Linux arm64 and x64, macOS, Windows x64; Windows on ARM gets the arm64 command with the x64 engine. Alpine gets the command, but the engine does not run on musl yet.
Checked in clean Ubuntu, Debian and Fedora containers, and as an upgrade from a real 0.12.0 install with a paired phone.

Beta: the old single program is still in every release as tether-node-<os>-<arch> for one more release. Report anything odd at https://github.com/Abhash-Chakraborty/inyon/issues.

Inyon 0.12.0

2026-10-13T09:02:58Z

The phone app pairs with a hub. Set up a computer: curl -fsSL https://inyon.abhashchakraborty.tech/get.sh | sh (Windows, in PowerShell: irm https://inyon.abhashchakraborty.tech/get.ps1 | iex).

Open a hub on your phone. On the hub's web app, Open on your phone (on the overview until a phone is paired, under Machines, and in Settings) shows a QR code and a typed code. In the app, Add → Connect to a hub scans it, or takes the hub's address and the code. From then on the phone reaches the hub itself, with no browser in between, and the hub's machines show next to the computers the phone pairs with directly.
Scoped and short-lived. The hub hands a code only to someone who signed in within the last ten minutes; it works once, for ten minutes, and five wrong tries cancel it. A paired phone gets its own token, listed under Settings on the hub with Forget, which cuts it off at once. The phone lists its hubs the same way.
Three ways to connect, named the same everywhere. Direct (the app over SSH, nothing installed), a computer running inyon (scan its code), or a hub (scan the hub's code, or open its web app).
A hub out of reach shows its machines as connecting until it answers; one that forgot the phone drops out with a word.
Pointing the phone's camera at a hub's code opens the download page, which hands the code to the app, as a computer's code does.

Inyon 0.11.1

2026-10-13T08:36:35Z

Motion and haptics, kept minimal. Set up a computer: curl -fsSL https://inyon.abhashchakraborty.tech/get.sh | sh (Windows, in PowerShell: irm https://inyon.abhashchakraborty.tech/get.ps1 | iex).

One motion system. Four durations (120 ms exits, 200 ms small moves, 320 ms cards and pages, 480 ms sheets only), two eases, distances of 2–8 px. Nothing shakes, bounces or overshoots, and a test keeps it that way.
Cards arrive, leave and move without jumping. A new session rises in; one that ends fades out and the others slide into place. Answering a prompt reads Sending, then Sent, and the card goes once the agent took it.
The mark does the waiting. While the hub is out of reach the kite's line draws itself in the header. Pull to refresh brings the mark down with your finger and turns it once; on a desktop a refresh button does the same.
Skeletons that say what they wait for. Every spinner standing in for content is now a skeleton in the shape of what will appear, with one line naming what is being waited for. Spinners stay only inside busy buttons.
Quieter marks. The provider logos no longer spin, twinkle or bob while an agent works; the state dot says it.
Haptics match. One light tick per touch, two short pulses only for a confirmed outcome (once per prompt), three for an error. Sending, confirming and opening a sheet no longer buzz on their own.
Smaller touches: the terminal rises in over the chat, a copied icon crossfades to a check, offline machines dim, toasts leave faster.
Reduced motion keeps the short fades and removes every move, on the web and through Android's "remove animations".

Inyon 0.11.0

2026-10-13T08:23:16Z

Speed and space. Nothing changes in how Inyon is set up or paired.

Set up a computer: curl -fsSL https://inyon.abhashchakraborty.tech/get.sh | sh (Windows, in PowerShell: irm https://inyon.abhashchakraborty.tech/get.ps1 | iex).

The app opens on the last thing it saw. It keeps the last overview and the last three chat pages on the device and draws them in the first frame, before the hub has answered. The hub's data then replaces them in place. Signing out clears them.
One card at a time. An update from the hub used to redraw every card; now only the session that changed redraws, and a burst of changes reaches the app as one message. On a throttled phone profile the longest frame during a burst of updates went from 150 ms to 67 ms.
Less to download on first open. The Latin fonts only (51 KB instead of 173 KB); the serif comes with the first Claude session. Syntax highlighting loads each language the first time a code block needs it, which halves the chat code. React sits in its own chunk, so it stays cached across app updates, and the service worker caches every chunk at install: a second open needs no network for the app itself.
The terminal draws with WebGL where the device has it, which keeps busy output smooth. Settings → About says which renderer is in use.
Smaller downloads for inyon. Each release file is also published gzipped, 38 MB instead of 84. The installers, inyon update and a hub handing the program to a new machine take the gzipped copy and check both checksums. The plain files stay for installs from before 0.11.
Ready for 0.13. The updater already knows the file names of the coming command-line program and engine, so machines will cross over by themselves.
inyon hub code shows a hub's setup code again, and inyon hub reset-password replaces a forgotten password.
The Android app paints the page's ground colour before its first frame, so nothing white shows after the splash.
The hub accepts an IPv6 address without brackets in the address bar.

Measured on a 2-core ARM server with a phone profile and a 10 Mbit link (apps/web/scripts/perf): first open 1.3 s → 1.2 s; second open 0.4 s → 0.3 s; the hub's round trip no longer sits in front of the first paint. Script time per overview update is about 15% lower; most of what remains is React itself.

Inyon 0.10.1

2026-10-13T04:54:17Z

Set up a computer with the short address:

shell

curl -fsSL https://inyon.abhashchakraborty.tech/get.sh | sh

On Windows, in PowerShell: irm https://inyon.abhashchakraborty.tech/get.ps1 | iex

Short install commands. The site serves each release's get.sh and get.ps1, so the one-liners above replace the long GitHub URLs. The app's Add a computer sheet shows them too. The programs themselves still download from this repo's releases and are checked against SHA256SUMS.
The site is only downloads and docs now. inyon.abhashchakraborty.tech no longer runs the web app, and nothing there connects to your computers. A computer's QR code scanned with the phone camera opens the download page, which offers to copy the pairing link for the app. For a browser, run your own hub (get.sh --hub).
End session no longer reports a failure when the agent was its pane's own command and took the pane with it.
Needs-you cards: the first answer button is ink, not the agent's colour.
Machines: the line under each machine wraps instead of cutting off, and reads "2 sessions · 2 agents".
Settings → Agents shows opencode instead of the flags Inyon adds to reach OpenCode's local API.

Inyon 0.10.0

2026-10-12T17:54:31Z

Inyon is one repo now. Releases, the Android app and the setup guide all live here, and the web app has its own address: inyon.abhashchakraborty.tech. The old inyon-releases address and its web page redirect here, and an older install updates to this release from there, then from this repo after that. Browsers keep a site's data per address, so a computer paired in the browser before has to be paired again, once.

Set up a computer:

shell

curl -fsSL https://github.com/Abhash-Chakraborty/inyon/releases/latest/download/get.sh | sh

Notifications with the app closed. Browsers get Web Push. A hub sends them itself; in the web app, each paired computer running inyon 0.10 sends them when an agent needs you or finishes. They're encrypted to your browser, and no Inyon server is involved.
Private networks. inyon finds Tailscale, Headscale, NetBird, ZeroTier and WireGuard, and answers on them as well as through the tunnel. The Android app on the same network connects straight to the computer.
Sessions by machine. The sidebar groups sessions by machine and tmux session, with folding and a search past eight. The overview groups its cards the same way. Machines shows whether each one is a server, a laptop or a desktop.
End session. From a session's menu or its card: the agent exits, then its tmux pane closes. Other windows aren't touched.
Fixed: the shell command note ran over the composer's rounded corner, and long shell commands ran out of their chat bubble.
The Android app no longer includes Firebase, and it's 192 KB smaller.

Inyon 0.9.0

2026-10-12T14:20:47Z

Inyon 0.8.0

2026-10-12T13:09:17Z

Inyon 0.7.0

2026-10-12T09:31:26Z

Inyon 0.6.5

2026-10-12T06:29:25Z

When another Claude session sends a message that needs your OK before it's delivered, the chat now shows the choice as buttons. Before, you had to open the terminal to pick one.

Fixes:

A message from another session stayed at the bottom of the chat as "Queued" after Claude had read it.
Helper agents a Claude session had started stayed under background activity as running after they finished.
A chat the hub had saved before a fix like these kept the old mistake. Saved chats are now read again once when the hub's reader changes.

tether-node 0.6.5 and the Android app are in tether-releases.

Inyon 0.6.4

2026-10-11T23:28:50Z

Updates are one tap now. Settings shows when the hub, a computer's tether-node or the Android app is behind, and Update brings it up to date. Nothing updates by itself. On the hub machine pnpm hub:update does the same, and on any computer tether-node update. If a new tether-node doesn't start, the old one comes back.

Renaming a session renames it in the agent itself, so the name is the same in the hub, the phone app and the agent's own resume list. If the agent is busy, the name goes in as soon as it's idle.

Codex chats show up when you pick an older thread with /resume, and typing $ in a Codex chat lists its skills. A skill you just installed shows up in the / and $ lists without reloading.

On the phone, pull down on the overview or the computers list to refresh.

Fixes:

Quitting an agent and starting a new one in the same pane showed the old conversation. The new one now starts empty.
After a Claude session was named, a numbered list in its last reply was taken for a question, which blocked sending.
An agent running in a folder that was deleted stopped showing its replies.

tether-node 0.6.4 and the Android app are in tether-releases.

Inyon 0.6.3

2026-10-11T20:53:13Z

Windows machines get a terminal. On a laptop running psmux, the terminal button opens the pane's screen and lets you type, use arrow keys and Ctrl+C, and paste. Long and multi-line messages now reach agents on Windows whole.

The message box keeps what you leave in it. A message you sent no longer comes back after you switch sessions and return, and text you erase stays erased, even while the agent is busy working. Changing the model or mode no longer shows up as a message in the chat, and an old goal no longer flashes up when a chat reopens.

Fixes:

Signing out, or changing the password, now disconnects browsers that were already open.
An answer that arrives late is refused if a different question is on screen by then, instead of picking the same number in the new one.
A turn that finishes while a machine is offline is reported when it's back, and a question that was already waiting isn't announced twice.
Scrolling back through a long chat on a bad connection no longer skips messages.
Two files with the same name uploaded at once no longer overwrite each other, and a file that fails to upload holds the message until you retry or remove it.
OpenCode's "Resume conversation" works, and restarting an agent keeps settings paths that have spaces in them.
Gemini and Codex chats are found in home folders with spaces in their names.
Enter in the model menu picks the model without sending your half-typed message, and menus fit short windows.
Forgetting a phone in tether-node ends any session it still had open. Uninstalling tether-node on Linux without systemd stops its background process too.
In the background the phone app reads open chats every 20 seconds instead of every 2, which saves battery and data.

tether-node 0.6.3 is in tether-releases.

Inyon 0.6.2

2026-10-11T18:17:29Z

Chats keep their place. A chat's saved copy is now written as soon as it loads, so reopening the app shows it at once and reads only what was said since. Long conversations open on their last stretch and load the rest as you scroll up.

Servers over SSH, without tether-node on them. Add a server from the phone and sign in with the phone's own key, a password, a private key you paste, or nothing at all. A server the phone can't reach directly can go through a paired computer that already SSHes to it.

Alerts while the app is closed. Stay connected is on by default and no longer stops after six hours a day on Android 15. The app asks Android once to let it run in the background, so the connection survives the screen going off.

Fixes:

A long message is no longer cut off when an old paste preview was still in Claude's input box.
A "needs you" notification goes away when the question is answered somewhere else.
Servers with tmux 3.4 and no locale list their sessions again.
Drafts, chats and machine lists are saved when the app goes to the background or the hub restarts.

Inyon 0.6.1

2026-10-11T10:30:08Z

Inyon 0.6.0

2026-10-11T10:19:19Z

Inyon 0.5.0

2026-10-11T02:55:39Z