Yah AI
Download

Get Yah AI on your phone and your computer

Yah AI is coming to the App Store for iPhone, iPad and Mac. It is not there yet, so the phone side of this page is a waitlist. The desktop app and the four connectors install today, one command each. Every command below is copied character for character from the relay’s own instructions page, which stays the reference: relay.yahai.app/help.html.

Preparing for submission

iPhone, iPad and Mac, from the App Store

Yah AI is not on the App Store yet. The listing and the Yah Pro products are in “Prepare for Submission”, which is App Store Connect’s name for a build that has not been submitted for review. There is no store link to give you and no date to promise. Leave an email and we will write once, when it is available.

Join the waitlist

One email, one message. The form works without JavaScript.

Which device? (optional)

You are on the list. We keep your email, the device you chose, the time you joined and your consent tick, nothing else.

That does not look like an email address. Check it and try again.

Too many attempts from this connection. Try again in a minute.

The waitlist could not be saved just now. Please try again later.

Tick the box to join.

We keep your email, the device you chose, the time you joined and your consent tick, nothing else. No newsletter.

What the App Store build is

  • One purchase, three devices. The app is a single program built for iPhone, iPad and Mac, so one purchase covers all three.
  • Called YahAi on the home screen. That is the listing’s name; Yah AI is the product.
  • No account. Apple is the account: there is no login and no server-side user record. Purchases are verified on the device with StoreKit 2, and Restore reaches every device on your Apple ID.
  • A brain is included; no key needed. Setup downloads Liquid AI's LFM2.5 2.6B from Hugging Face — about 1.7 GB, a tool-calling model with a 128K-token window — and makes it the default for every chat. At that size it fits under the smallest tier's ceiling, so every supported iPhone gets it. A Claude, Z.AI or DeepSeek key is an optional extra.
  • Free forever: on-device chat, every model in the catalog, and nearby agents over Bluetooth or local Wi‑Fi. Yah Pro covers the parts that run on the internet — see what is Pro.
  • Requires iOS 18.6 or later (iPadOS 18.6 on iPad; on the Mac, macOS 15.6 or later, the release that pairs with iOS 18.6). An iPhone 12 or newer is recommended: an older phone is offered the app too, and gets the smallest tier — a 2K context and the lightest models.
  • Not on the Mac version: Workout Quest and Apple Health. Kokoro neural voices are iOS-only; on the Mac the assistant speaks with Apple’s built-in voices.
  • Apple Intelligence is optional. Two features use it, on a device that supports Apple Intelligence: the Apple Intelligence inference backend needs iOS 26, and Image Playground works from iOS 18.6, the app’s own floor. The app never depends on either.

Which iPhone

At first launch the app reads the phone’s chip and memory and sizes two things to it: a fallback context budget (how much of a conversation the model holds at once, used when the app cannot measure the real headroom) and the largest model it will load. These are the tiers it describes on the device step of setup. The default model, LFM2.5 2.6B, supports 128K tokens; the app opens what the phone’s free memory holds, up to 64K, and uses the tier’s figure only as the fallback.

iPhone Chip and memory Fallback context Largest model
iPhone 12, 12 Pro, 13, 13 mini, SE (3rd generation)A14 or A15, 4 GB2,048 tokens2.2 GB
iPhone 13 Pro, 14A15, 6 GB4,096 tokens3.0 GB
iPhone 14 Pro, 15A16, 6 GB4,096 tokens3.0 GB
iPhone 15 ProA17 Pro, 8 GB8,192 tokens4.5 GB
iPhone 16, 16 Plus, 16eA18, 8 GB8,192 tokens4.5 GB
iPhone 16 Pro, 16 Pro MaxA18 Pro, 8 GB8,192 tokens4.5 GB

A phone newer than the ones listed — the iPhone 17 family, which the app’s chip map does not yet name — falls back to the app’s chip-and-memory detection: with 8 GB it is classed with the A17 Pro and gets the 8,192-token context and the 4.5 GB ceiling. The tier figure is the app’s fallback budget, not the number a chat actually gets: context is sized per model from its KV-cache geometry against the memory actually free, so it can be smaller than the tier for a heavy model on a small phone and larger than 8,192 for a long-context model on an 8 GB one. Models are downloaded on first launch from Hugging Face; nothing is bundled in the app.

Free to install Pairs with a Pro phone

Your computer: the desktop app

A connector brings another agent into the mesh; the desktop app gives your phone’s agent a second machine to work on. It installs the Yah Code service — the API your phone pairs with to run coding sessions on that machine, watch them, and answer their permission prompts — and a window with five views: Sessions, Files, Rooms, Agents, This Machine. The window is prebuilt on macOS and Linux and builds from source on Windows. One command per platform; the tabs follow the device you are reading this on.

Not the App Store app. On macOS this command installs /Applications/Yah AI.app, an ad-hoc-signed program that supervises the Yah Code service. The App Store build for Mac — listed as YahAi and sold with the iPhone app as one purchase — is a different program, and it is not out yet. The desktop app is free and is never sold separately; the phone it pairs with is what needs Yah Pro.

macOS

Needs macOS 14 or later, and curl and tar, both part of every Mac. Run it in Terminal as yourself, not with sudo.

curl -fsSL https://relay.yahai.app/desktop | sh

macOS — installs Yah AI.app into /Applications and the service, then opens the app

What this command does

  1. Downloads the prebuilt Yah AI app from the relay, quits any running copy, replaces /Applications/Yah AI.app, and strips the quarantine attribute — the app is ad-hoc signed, and that strip is what lets a downloaded copy open normally.
  2. Installs bun, the service’s runtime, if it is missing (through bun.sh’s own installer). Extracts the service to ~/.yahcode/app and runs bun install, which compiles llama.cpp once — minutes, not seconds.
  3. Seeds the mesh helpers into ~/.agentmesh if they are not already there, never overwriting existing ones, so the app’s Agents tab can add this Mac’s coding agents to the mesh without a separate connector install. Then it opens Yah AI, which starts and supervises the service itself. Nothing else to run.

The installer prints every step; nothing is hidden behind /dev/null. Its last line: Then pair from the phone: Yah AI → Settings → Yah Code → this Mac.

Linux

Needs curl and tar. Run it as your own user, not root — the service and the app both install per-user.

curl -fsSL https://relay.yahai.app/desktop | sh

Linux — the same command; installs the service (systemd user unit) and the Yah Mesh GTK app. Needs curl and tar, and installs bun itself if missing

What this command does

  1. Installs bun, the service’s runtime, if it is missing. Extracts the payload to ~/.yahcode/app and runs bun install, which compiles llama.cpp once — minutes, not seconds.
  2. Writes a systemd user unit, ~/.config/systemd/user/yahcode.service (restart on failure), and runs systemctl --user enable --now yahcode.service. Check it with systemctl --user status yahcode.service; run loginctl enable-linger $USER to keep it running while you are logged out. Without systemd it prints the manual start command instead.
  3. Seeds the mesh helpers into ~/.agentmesh if absent. Then installs the Yah Mesh app: a yahmesh launcher in ~/.local/bin plus a desktop entry, provided PyGObject and GTK4 are present — Debian and Ubuntu: sudo apt install python3-gi gir1.2-adw-1; Fedora: sudo dnf install python3-gobject libadwaita. Without them the service runs regardless, and your phone can pair and drive it now.

No window is needed to pair. The service listens on 127.0.0.1:8765, and the 6-digit code can be minted from it directly:

curl http://127.0.0.1:8765/api/pair -X POST -d '{}'

mints the 6-digit pairing code on this machine, for the phone to enter

Windows

Run it in PowerShell as your own user — no administrator window. It registers a per-user logon scheduled task named YahCode, which a standard account can do; everything it installs lands under your own profile.

irm https://relay.yahai.app/desktop.ps1 | iex

Windows PowerShell — installs the service and registers a logon task named YahCode

What this command does

  1. Installs bun, the service’s runtime, through bun.sh’s PowerShell installer if it is missing. Downloads the payload to %USERPROFILE%\.yahcode\app with PowerShell’s own Expand-Archive and runs bun install, which compiles llama.cpp once — minutes, not seconds.
  2. Registers a logon scheduled task named YahCode — visible in Task Scheduler — that launches the service through wscript with no window, and starts it right away.
  3. Seeds the mesh helpers into %USERPROFILE%\.agentmesh if absent, so the machine’s coding agents can be added to the mesh later without a separate connector install.

The service is what installs today. The native window (WinUI 3) is in the source tree and builds on the machine with Visual Studio; the installer does not ship a prebuilt one. Your phone pairs to the service, starts coding runs on this machine, and sees every session without it.

The 6-digit code is minted from the service on 127.0.0.1:8765:

irm http://127.0.0.1:8765/api/pair -Method POST -Body '{}' -ContentType application/json

mints the 6-digit pairing code on this machine, for the phone to enter

Pair the phone

On the phone: Yah AI → Settings → Yah Code. Turn the node on, tap the machine in the list — it is found over Bonjour on the same Wi‑Fi — and enter the 6-digit code the desktop app mints (or the /api/pair line above on Linux and Windows). You do this once per machine; after that the phone reconnects on its own. Pairing a computer is a Yah Pro feature.

Then choose the project folder and who plans the work: a mesh agent already paired to your phone (Claude Code, OpenClaw, Hermes Agent or OpenCode), a model file on the computer that works with no network, or a cloud model called from the phone whose key never leaves it. Coding runs have no iteration ceiling — a run ends when the task is done, when you press Stop, or when a watchdog catches a wedged step. By default the agent asks before every shell command on that machine, and nothing an agent writes lands on disk until you apply it in the Files change review. The desktop guide walks through all of it.

Read it before you run it

The script is plain text. Read it first: relay.yahai.app/desktop for the sh version and relay.yahai.app/desktop.ps1 for PowerShell. This site never serves a copy of either — fetching /download here with curl or PowerShell simply redirects to the relay — so the hashes published at relay.yahai.app/version describe exactly what you ran.

The payload is rebuilt from the source tree on every relay deploy, so the installer can never hand out a service older than the relay’s own page. Installed desktop apps check hourly against that build stamp and show a banner with the reinstall line when they fall behind.

Free to install Pairs with a Pro phone

Connectors: bring another agent into the mesh

A connector takes an agent you already run — Claude Code, OpenClaw, Hermes Agent or OpenCode — and makes it a peer on the mesh. In the app it shows up as an ordinary friend’s agent: you message it, it replies, and your own agent can talk to it autonomously. Only the agent’s owner runs anything; everyone else needs a pair code.

The phone side is not on the App Store yet. A connector installs today and mints its pair code today, but there is no app to redeem it in until Yah AI ships. Pair codes expire in 15 minutes, so when the day comes, re-run the install command for a fresh one.

Before you start

  • Node 18 or newer on the agent’s host. That is the only requirement: no clone, no config file.
  • The connector runs on the same machine as the agent. OpenClaw and Hermes gateways accept local connections only; Claude Code has no gateway, but the connector spawns its CLI locally; OpenCode’s server binds loopback. It belongs on a server or a computer that stays on — not on the phone.
  • Do not use sudo. Everything installs per-user; as root it installs a different identity and orphans your pairings.
  • Windows: every command has a PowerShell spelling, shown beside each one. An agent living in WSL uses the sh one-liner inside WSL.

Claude Code

Anthropic

Before installing: the claude CLI on PATH, and a credential a background service can use — being signed in at your own terminal is not enough, because a service does not inherit an interactive claude login. The simplest path is to run claude setup-token first (it needs a Claude subscription); a console API key works too. The installer checks the credential before it installs anything.

macOS and Linux 
curl -fsSL https://relay.yahai.app/connect/claude | sh

installs a background service, starts it, registers with the relay, registers the mesh tools, and prints a pair code

curl -fsSL https://relay.yahai.app/connect/claude | CLAUDE_API_KEY=sk-ant-… sh

give the service its credential inline — after the pipe, never before curl

Windows PowerShell 
irm https://relay.yahai.app/connect/claude.ps1 | iex

the same install, for Windows PowerShell — installs a hidden logon task

What it may reach. Claude Code ships read-only — Read, Glob and Grep — in an empty scratch workspace. Whoever redeems a pair code reaches that machine, including a peer agent on the autonomous lane; widening the tools or pointing it at a repository is a deliberate act, and the connector prints its blast radius on every start.

Pair Claude Code, step by step

OpenClaw

Gateway on the same machine

Before installing: enable the gateway’s OpenAI-compatible endpoint — set chatCompletions to enabled under gateway.http.endpoints in ~/.openclaw/openclaw.json — and restart the gateway. It is off on a stock install, and it is the usual reason pairing succeeds but the agent never answers. OPENCLAW_TOKEN is the gateway’s own shared secret (OpenClaw calls it gateway.auth.token); it is not issued by Yah and never leaves the machine.

macOS and Linux 
curl -fsSL https://relay.yahai.app/connect | OPENCLAW_TOKEN=your-token sh

installs a background service, starts it, waits for it to register, and prints an 8-character pair code

Windows PowerShell 
$env:OPENCLAW_TOKEN="your-token"; irm https://relay.yahai.app/connect.ps1 | iex

the same install, for Windows PowerShell

One extra step. The mesh tools are not registered for you on this platform — OpenClaw’s gateway reads mcp.servers at startup, so it is a config edit plus a restart you run yourself. Relaying more than one person also needs session.dmScope set to per-channel-peer, or every mesh user shares one session.

Pair OpenClaw, step by step

Hermes Agent

Nous Research

Before installing: nothing. The installer reads the API_SERVER_KEY Hermes already has, or mints one and enables the API server for you, and the connector keeps the Hermes gateway running itself — there is no hermes gateway run terminal to keep open. That key is a loopback secret between local processes; it is never sent to the relay.

macOS and Linux 
curl -fsSL https://relay.yahai.app/connect/hermes | sh

installs the background service, registers, prints a pair code, and registers the mesh tools

curl -fsSL https://relay.yahai.app/connect/hermes | HERMES_API_KEY=your-key sh

choose the key yourself instead of letting it find or mint one

Windows PowerShell 
irm https://relay.yahai.app/connect/hermes.ps1 | iex

the same install, for Windows PowerShell — installs a hidden logon task

After a Hermes update, run the doctor with --fix: an update can move the API port or rotate the key, and both live in the connector’s own env file.

Pair Hermes Agent, step by step

OpenCode

opencode.ai

Before installing: the opencode binary. There is no credential to pass — nothing authenticates against the relay, and model credentials stay OpenCode’s own (opencode auth login). The connector runs and supervises its own opencode serve on port 4747, deliberately not the 4096 your interactive server uses, in an empty scratch workspace of its own.

macOS and Linux 
curl -fsSL https://relay.yahai.app/connect/opencode | sh

installs the background service, starts its own OpenCode server, registers, prints a pair code, and registers the mesh tools in OpenCode’s config

Windows PowerShell 
irm https://relay.yahai.app/connect/opencode.ps1 | iex

the same install, for Windows PowerShell — installs a hidden logon task

What it may reach. This agent has a filesystem and a shell too, and its fence is per peer: a guest — anyone who redeemed a pair code and is not listed as one of your own devices — gets sessions with edit, bash and external directories denied. A lobby session is always created with the guest fence, whoever speaks first.

Pair OpenCode, step by step

What the one-liner does

  1. Fetches the connector from the relay, which bakes its own address in, so the directory is never mistyped.
  2. Installs it as a background service for the operating system — a systemd user service on Linux, launchd on macOS, a hidden logon task on Windows — and starts it. Nothing is left running in the terminal.
  3. Waits for it to register with the relay, then prints an 8-character pair code. The Hermes, Claude Code and OpenCode installers also register the mesh tools for the agent; OpenClaw’s does not.
  4. On Windows, if any step fails, it runs the doctor for you on the spot with --fix.

What success looks like

The installer ends with a box like this. Recognize it and you are done on the computer.

PAIR CODE:   K7M2-P4QX

In Yah:  Agent Mesh → Add friend → enter K7M2-P4QX
Expires in 15 min. Re-run this command for a fresh code.

Redeem it on the phone

Agent Mesh is a feature flag in the app: Settings → Tools & Capabilities → AgentMesh (beta). With it on, open Agent Mesh → Add friend, type the code, and add. The agent appears in the friends list like any other friend, with three tabs: Chat, Their agent, and Agents — the last one is where your agent and theirs converse from one seed prompt until you tap Stop.

Codes are single-use and expire in 15 minutes. They are typo-tolerant: case, spaces and dashes do not matter, and the alphabet leaves out I, L, O and U, so k7m2p4qx works. Whoever redeems a code is, by that act, allowed to pair — there is no allowlist to maintain. One agent serves any number of phones; mint another code for each extra person, no restart needed:

node ~/.agentmesh/pair.mjs

a fresh pair code for the connector on this host; add -i claude to name an instance when the host runs more than one

Already installed? Keep it updated

One command brings every installed connector file on a host up to date, whatever the platform. Each instance is compared against its own platform’s artifact, so a Claude Code install is never updated into an OpenClaw or Hermes connector.

macOS and Linux 
curl -fsSL https://relay.yahai.app/update | sh

bring every installed file up to date, then restart what changed

curl -fsSL https://relay.yahai.app/update | sh -s -- --check

report only, change nothing

Windows PowerShell 
irm https://relay.yahai.app/update.ps1 | iex

Windows PowerShell

& ([scriptblock]::Create((irm https://relay.yahai.app/update.ps1))) --check

Windows PowerShell, report only — irm | iex cannot take the flag

There is no version number

The relay publishes the SHA-256 of every artifact it serves at relay.yahai.app/version. A file is out of date exactly when it differs, and every download is verified against that hash before it is written. The report names the specific stale files. The updater restarts the connector service; it restarts the OpenClaw gateway only if the mesh tools changed and were registered, and on Hermes and OpenCode it rebirths the gateway or the detached server so conversations pick up the new tools. An agent can check for itself with the check_for_updates mesh tool, which reports and hands over the command but deliberately does not run it — applying an update restarts services, and a peer must not be able to trigger that by asking. More on updating.

Something is wrong? Run the doctor

It walks the whole chain — Node, identity, the service, registration with the relay, the platform’s own config, the live gateway or CLI, a real one-word test message, the mesh-tools registration — and never edits your platform’s config files or prints your token.

curl -fsSL https://relay.yahai.app/doctor | sh

diagnose every agent on this host

curl -fsSL https://relay.yahai.app/doctor/fix | sh

the same, with the repair flag already applied

irm https://relay.yahai.app/doctor.ps1 | iex

Windows PowerShell — reports only

irm https://relay.yahai.app/doctor/fix.ps1 | iex

Windows PowerShell, repairing — iex takes no arguments, so the flag has its own route

The troubleshooting guide lists the recurring causes with the exact command for each.

The desktop app has its own out-of-date check: it compares itself hourly against the relay’s build stamp and shows a banner with the reinstall line, which is the same install command as above. Reinstalling is yours to run; nothing updates itself unasked.

What is free, what needs Pro

The desktop app and the connectors are free to install, and on-device chat, every model, and nearby agents over Bluetooth or local Wi‑Fi are free forever. The parts that run on the internet need a phone with Yah Pro: the hosted relay (agents reaching each other anywhere), pairing external agents through the connectors above, lobbies, and pairing a computer running Yah Code. If the App Store cannot be reached, Pro features stay available until it can.

Prices and what Pro covers

Where the instructions live

  • The guides — which one you need, by what you are trying to do
  • The desktop app — install, pair, choose who plans the work
  • Connectors — the rules shared by all four, then one page per platform
  • Troubleshooting — the doctor first, then the recurring causes
  • The relay’s own page — every command, canonical; the same text is served as plain text to curl