Changelog

User-facing changes to yothere, newest first. Versions follow semver. Install or upgrade with pipx install yothere / pipx upgrade yothere.

[1.34.1] - 2026-08-11

Fixed

• More places that look for Claude Code now find it. 1.34.0 fixed the one that runs your work; this fixes the rest, including the startup check that decides whether your machine can pick up work at all. On a machine where Claude Code was installed with the native installer, that check could refuse to start and retry in a loop, while claude worked perfectly in a terminal.

[1.34.0] - 2026-08-11

Fixed

• A hosted task no longer fails with “claude executable not found” on a machine where Claude Code is installed and working. If you installed Claude Code with the native installer, the binary lives in ~/.local/bin, which a background service does not see, and yothere’s only fallback was the older npm location. Every hosted task on that machine stopped and asked you to install something you already had. yothere now looks in the places Claude Code actually installs to (and honors YOTHERE_CLAUDE_BIN if you want to name the path yourself), and it re-checks on every turn, so fixing the path no longer needs a restart.
• A working Codex install is no longer reported as missing. ChatGPT.app absorbed the standalone Codex app, so yothere was looking inside an app bundle current installs do not have. Both locations are checked now.

Added

• The cockpit is voice-first. Connect carries /overview alone: the command bar and Dispatch are hidden, and the mic button reappears whenever the mic is actually muted so there is always a way back. Pressing Connect now shows a live boot card instead of a silent wait, and says why when a first cold start runs long.
• The spoken greeting opens on the brand word, with no filler in front of it.

[1.33.0] - 2026-07-23

Added

• Settings shows a setup checklist for every machine. Each paired machine now lists its setup state — GitHub, connected repos, installed brains, and whether its yothere is current — and every gap names the exact command that closes it. While a gap is open the page keeps watching: run the fix on the machine and the row flips green by itself, no reload. A machine too old to report its setup gets one honest line (upgrade it and the checklist fills in), never a false list of gaps.
• Connect GitHub in one click. On a machine running this version, the checklist’s GitHub row becomes a Connect GitHub button: click it, a code appears on the page, type that code at github.com/login/device on any screen, and the row (and the cockpit chip, whose “How” is now a “Connect” door into Settings) goes green on the machine’s next check-in. The sign-in runs GitHub’s official device flow on your own machine; yothere keeps no token, and the secret half of the flow never leaves your computer. Clicking twice starts one sign-in, not two; a failed attempt says why and offers the button again. Machines on older versions keep the yothere setup-github command, which does the same thing from the terminal.
• The voice agent can walk you through setup. If your machine is paired but GitHub or a repo is still missing on it, a call now opens with a one-sentence offer to finish setting up. Say yes and it walks you through one step at a time — and it only ever confirms a step worked by re-checking the machine, never by assuming.

[1.32.0] - 2026-07-23

Fixed

• Approving a send now delivers it. When a send needed your sign-off, the worker could ask with a plain question card instead of the draft-with-Send-button card, and replying “send” to a question unlocks nothing, so the approved message never left. Blocked sends are now steered into the proper approval card, and the gate no longer misreads harmless read-only commands (like inspecting the sender script) as sends.
• Interrupting the voice bot now stops it. A short interjection (“send”, “stop”) could be mistaken for speaker echo, and the bot would resume talking right over you. The echo check waits longer, trusts what the model actually heard, and corrects itself the moment your words come through, so a real interruption stays stopped.

Added

• Operator analytics: paid conversion as a funnel milestone and first-touch attribution across the site-to-app boundary (disclosed on /privacy; nothing changes on your machine).

[1.31.0] - 2026-07-21

Fixed

• Reliability sweep across the whole product. A full audit of every subsystem (every finding adversarially verified before it was fixed), focused on running unattended without anyone watching:
  • Stop now sticks on your own machine. Stopping a task a local worker was mid-way through used to be silently undone when the turn finished; the cancel is now honored the moment the turn lands, same as hosted machines.
  • Hosted voice calls speak your language. The language you pick in Settings now actually reaches the hosted voice worker; previously every hosted call ran in English regardless.
  • A bad release can no longer strand a machine. If a self-update installs a release that fails its own verification, the machine rolls back to the version that was working instead of crash-looping.
  • Fewer silent failures. Failed phone/Telegram alerts now retry instead of being suppressed for hours; a machine that loses contact with yothere backs off and says so instead of spinning silently; crashes leave a real trace.
  • Snappier voice sessions. Slow lookups no longer freeze live audio, a follow-up on a still-running task no longer double-runs it, and the assistant no longer interrupts its own long answers.
• Privacy hardening. An approved-but-unused device pairing code now expires like everything else, and deleting your account removes device-code records along with the rest of your data.

[1.30.0] - 2026-07-17

Added

• Stop actually stops things. Typing “cancel this request” (or “stop”, “never mind”) at the command bar now cancels the most recent task you dispatched instead of spawning a new agent to “execute” the cancellation. Running work cards get a Stop button (queued cards keep Cancel): stopping a turn that a machine is already executing marks it “stopping”, discards that turn’s result when it lands, and parks the thread — your Stop always wins, even on machines running an older yothere. A task that merely contains a cancel verb (“cancel my hotel booking”) still dispatches normally.

[1.29.2] - 2026-07-17

Fixed

• The cockpit no longer strands on “Loading…” when the live stream stalls. The fleet view paints only on a /live SSE state frame, so a frame withheld by a buffering proxy, or a stream that died silently while the tab was backgrounded (e.g. the PWA left open across a phone call), left the inbox blank or stale until a full manual reload. The /live response now sends anti-buffering headers and primes the stream so an intermediary flushes it immediately, and the cockpit reconnects a fresh EventSource on return-to-foreground, on a silent-stall heartbeat, and in the first-frame watchdog. The dispatched work was always running; only the live view was stranded. (#283)

[1.29.1] - 2026-07-17

Fixed

• Self-update no longer parks forever on pipx venvs without pip. selfupdate.run_upgrade() ran python -m pip install for the pip-venv flavor, which fails rc=1 “No module named pip” on pipx app venvs that ship without pip (modern pipx no longer seeds a shared pipx_shared.pth). A machine with “Automatic updates” on then stamped a 6h backoff and never recovered, silently staying on the old version. run_upgrade() now probes python -c "import pip" and bootstraps pip with the stdlib’s ensurepip before installing. Healthy venvs are byte-for-byte unchanged; uv-tool is never probed; a failed bootstrap parks the same backoff and keeps serving on the old code. (#281)

[1.29.0] - 2026-07-17

Added

• OpenClaw is a third brain (openclaw), alongside claude and codex. yothere runs turns through openclaw agent --local behind the same TurnBackend seam. Pinned and probed against openclaw 2026.7.1 (OPENCLAW_TESTED_VERSIONS); capabilities WARNs on any other version. Model routing is openclaw’s own (YOTHERE_OPENCLAW_MODEL, default deepseek/deepseek-chat); cost is estimated from tokens (openclaw reports no dollars). See docs/openclaw-backend.md.
• Containment for openclaw is config-borne (no deny hook), observe + workspace tiers only. openclaw’s exec policy is deny | allowlist | full with no allow-all-minus-denylist and no pre-exec veto hook, so the claude/codex “full shell + send-deny gate” is inexpressible. A policy asking for the full posture degrades closed to workspace; security=full is never emitted. Observe denies all shell; workspace runs a safe build/read allowlist (no git push, no outward senders). The outward-acting tool surface (message/cron/nodes/gateway/…) is denied at the tool layer.
• New knobs: YOTHERE_OPENCLAW_BIN, YOTHERE_OPENCLAW_MODEL, YOTHERE_OPENCLAW_HOME, YOTHERE_OPENCLAW_PRICE_TABLE, and openclaw_model in the thread config.

Notes

• The voice path and task-source jobs build their own claude -p argv and bypass the seam; they remain claude-only by design.

1.28.0 (2026-07-17)

• Codex is a first-class brain in the cockpit, not just Claude. Each paired machine now shows which brains it can run (Claude / Codex). A Codex that is installed but not signed into yothere shows the one-line codex login fix, the account model card is retitled Claude models and names Codex as a separate per-machine brain with its own model, and onboarding names Codex when both agent CLIs are installed.
• Complex tasks plan first, on every dispatch surface. A task that batches several changes, or investigates and then fixes a named problem, now drafts a plan for your ok before it runs instead of charging ahead; a plain confirmation or a quick lookup still runs straight through.
• Choose your Claude model. Settings has a model picker (Sonnet or Opus, with a separate pick for the higher-stakes planning lane) that applies across every machine you pair.
• Machines can keep themselves up to date. Opt a machine in and it upgrades yothere from PyPI and restarts its service itself, only while idle.
• Pick the repo at dispatch, and name your machines. Dispatch has a repo picker, and paired machines get editable labels so an “unnamed machine” becomes “office mac”.
• Provable phone alerts. A test-push button, immediate blocking asks, and push on iOS and Android, so you can confirm notifications actually reach your phone.
• Delegate from your editor. A coding agent can hand a separable chunk of its task to the fleet via the MCP spawn_thread (now with a repo param) and a new list_workspaces tool.
• 7-day free trial, no credit card. The hosted cockpit starts free for a week with full access; after that it is the $20/mo (USD) Founding price, locked in for as long as you stay.
• Inbox and cockpit reading polish. Finished-lookup cards reflow into a lede plus bullets instead of a wall of text, cockpit type is a touch larger for laptop legibility, every lane reads newest-first, and muting a call now cuts only your microphone while yothere keeps speaking results aloud.

1.27.0 (2026-07-16)

• Deleting your account now offboards your machines honestly. Every paired machine is de-authorized the moment you delete (that was always true), and the machine now notices: a worker whose credential is gone stops its own background service instead of retrying forever, and prints the removal commands. Deletion ends on a /goodbye page that names the one thing we cannot do from our side — the installed software and local thread files on your own computers — with the exact commands to remove them. The settings page discloses the same before you confirm.
• An opened result fold stays open. Expanding “full result”, a plan’s step tree, a diff patch, or a Done card’s session view used to snap shut about a second later when the live view refreshed. Open folds now survive every refresh.
• Voice answers machine questions about your machines. Asking the call “can you deploy?” now reflects what your paired machine can do, not the host running the call, and a finished task’s result is no longer re-offered or claimed ready before it is.

1.26.0 (2026-07-16)

• A Done card can replay the whole session. Finished threads used to show one summary line; each Done card now expands into the full session — the task, every worker turn with its tool activity, your own replies and decisions, and the final outcome.
• A killed machine no longer freezes your queue. If the worker process on a paired machine dies mid-task (laptop shutdown, upgrade), the queue recovers in seconds instead of waiting out a 15-minute lease, and a machine that goes quiet mid-turn is now visible on the thread card.
• Voice one-click, honestly. A busy line says busy (not down), and a caller with no machine connected is told so at the greeting with a pairing walkthrough. The Founding plan’s hosted-voice allowance (120 min/day) is stated everywhere the plan is sold and enforced with a usage meter in Settings.
• First-run polish. Onboarding puts pairing first, dispatching with no machine connected says so instead of failing quietly, and the old paste-a-token pairing block is gone from the UI entirely — the browser device flow is the pairing path.

1.25.0 (2026-07-16)

• Pair a machine in your browser, no token to paste. yothere login now defaults to a browser device flow (RFC 8628): it prints a short code and an app.yothere.ai/activate link, and you approve the machine in your own logged-in browser, where you see which machine is asking, pick its permission tier (fail-closed to observe), and tick a bypass-consent box for the full tier. No secret and no agent-directed text ever passes through the coding agent, which closes the paste-a-block-that-instructs-the-agent problem at the root. The legacy yothere login --url .. --token .. path stays for self-host and headless boxes.

1.24.0 (2026-07-15)

• The cockpit and every account page now wear the brand. The web app moved off the old dark palette to match the marketing site’s “slate” brand: a light paper ground, a lilac accent, self-hosted Switzer type, and the orange brand caret as the favicon. Login, signup, onboarding, settings, and billing all get one consistent lilac primary button and the caret favicon they lacked.

1.23.0 (2026-07-15)

• The privacy release. A GDPR-oriented pass over what yothere stores, for how long, and how it is erased. Voice call content no longer persists on our servers after a call: every terminal transition clears the transcript, session snapshot, and network-signaling data, and the hosted voice worker never writes call content to its own disk. Retention windows now run by default (voice metadata 30d, finished tasks 7d, auth history 24h to 7d, error logs 90d, and more), with a two-stage reaper for deleted tenants, and account deletion reaches every table.
• Erase your own local artifacts. yothere local wipe clears the call transcripts, failed-turn logs, and call debriefs yothere keeps on your disk. A settled thread can now be truly deleted from the cockpit (distinct from Dismiss, which archives), and operators get yothere admin export / yothere admin delete for data-subject requests. The remote-brain token is encrypted at rest with Fernet when YOTHERE_DB_CRYPT_KEY is set.

1.22.0 (2026-07-15)

• Build a feature by voice, review the diff on your phone, ship it, watch CI, merge, deploy. The whole publish rail, reviewed and made honest. Dispatch a feature into a registered git repo, hear the plan read back and approve it, watch it build in its own git worktree, review the diff on a card, say (or tap) “Ship it”, watch CI, and merge on green. Works on Claude or Codex, end to end by voice. Each machine also probes what it can actually do (git, gh auth, installed harnesses, connected repos) and the cockpit only offers buttons the box can back; missing GitHub auth is a host-side device-flow sign-in with no token on disk.
• Adversarial security review of the publish rail. Nine attack lenses, two host-side confused-deputy bugs found and fixed (each watched red before green): the control plane now strips publish-rail keys from any non-publish result, and a workspace’s deploy command is snapshotted at dispatch rather than re-read at merge. The publishing claim is now split honestly across SECURITY.md, the pairing block, and the consent text: the approval mechanism never authorizes a push (absolute), while the in-turn full-tier deny is best-effort argv inspection, not a sandbox.

1.21.2 (2026-07-14)

• A new hold-music track now actually reaches listeners. The loop was served under a stable name with a week-long cache, so Cloudflare kept handing out the old bytes after a change. The page now requests the music by its content hash, so new bytes are a new URL and the edge misses once.

1.21.1 (2026-07-14)

• Hold music: happier track, half the volume, a gentler arrival. The waiting loop is now “City Sunshine” instead of “Study and Relax”, at half the gain with a 3s fade-in, and playback starts past the loop seam so the crossfade only ever plays on the wrap.

1.21.0 (2026-07-14)

• Hold music on voice connect. The cockpit fades in a quiet waiting loop from the Connect click until yothere is first heard, then fades it out, bridging the hosted cold-start wait so you are not staring at silence while the call boots.

1.20.0 (2026-07-14)

• Per-machine permission tiers. Pair a machine observe (read-only), workspace, or full, chosen as a checkbox ladder at pairing and editable in Settings → Machines. New pairings default to observe. Enforcement binds even over a box’s own ~/.claude allow rules: generated deny rules plus a fail-closed path gate on Claude Code, and the native OS sandbox on Codex. The local YOTHERE_WORKER_PERMISSION_MODE is a hard cap the server can never raise above, and a restricted machine on a wheel too old to enforce its tier is held rather than leased.

1.19.0 (2026-07-14)

• Mute yourself on a call. A mic button in the cockpit, and you can also just say “mute me”. It is a hard mute: the browser detaches the mic and the server drops any muted audio that reaches it anyway, so nothing you say while muted is heard. Muting also holds the proactive nudges, so yothere does not monologue at a dead microphone. There is deliberately no spoken unmute (the audio carrying the word “unmute” never arrives), so the button is the only way back, and talking into a muted mic tells you so instead of leaving you wondering.
• Threads can build software. Register a git repo you already have with yothere workspace add <name> <path> (yothere never clones), then hail a change: yothere spawn --repo <name> "fix the layout shift on the pricing page". Code verbs (fix, add, implement, refactor, rename, and the rest) now parse as hails, so that sentence is the whole interface. The repo is bound at spawn, with --repo. The thread runs in its own git worktree on its own branch, so it cannot touch your working tree or another thread’s, and it commits its work and hands back a summary and a commit sha for you to read.
• A code thread still cannot push, and no approval can unlock it. git push, gh api and the mutating gh subcommands stay on the never-grant list: no PR, no merge, no push, whatever you click. The worker is told this up front, so it commits its branch instead of burning its turn hunting for a workaround.

1.18.5 (2026-07-13)

• Calls are transcribed as they happen. A transcript is now appended line by line as the call runs, so it survives a call that never hangs up cleanly, which is why a long call used to leave almost nothing behind. A hosted call runs on our media worker, so its transcript is stored with the call on the control plane, which is what you read back in the cockpit; it does not stay on your machine (Privacy). The audio itself is not recorded.
• Neutral Latin American Spanish is a setting. A workspace can choose Español (Latinoamérica) in the cockpit’s /settings and get an agent that plans, asks, reports, and speaks in it. English is the default for every account, and /settings is the only place the choice is made.
• The voice stops re-greeting you. It used to open with its own name again mid-call on every reconnect or unprompted turn; the greeting is now a one-time event, and a long answer no longer ends with filler that re-opened the conversation.
• A gated task can no longer fail in silence. A task blocked by the send-gate used to burn its whole time budget hunting for a workaround and then report nothing. The worker now names the gate up front, treats a fast block as a good outcome, and comes back to ask you.
• A follow-up question no longer spawns a second thread. “What do you mean that didn’t go through” is now read as a follow-up on the thread you are looking at, not as fresh ten-minute work.

1.18.4 (2026-07-13)

• Pick a finished thread back up by voice. Ask about “that pricing plan from Tuesday” and yothere resolves the finished thread you mean, names the match, and waits for your yes before touching it. Reopening is never the default: a new request still spawns a new thread and never reads your history, and a wrong match is a miss rather than a guess.

1.18.3 (2026-07-13)

• An FYI now reaches the Inbox. A non-blocking notice (“Booked the flight, no action needed”) from a thread that keeps working used to sit silently in the Working column and never surface. FYIs land in the Inbox now; only genuinely blocking asks are ever cleared from a card.

1.18.2 (2026-07-13)

• Live progress during a voice call, not just after you hang up. A task you dispatched during a call used to show a blank card until the call ended, then light up backwards. The card now shows what the turn is doing while you are still on the call.

1.18.1 (2026-07-13)

• Live progress on the tasks you actually dispatch. The working-card activity line reached fleet cards but not anything dispatched from the cockpit, which is most real use. A dispatched task’s card now shows its thread’s live activity.

1.18.0 (2026-07-13)

• The working card says what the turn is doing right now. Each tool call is one timeline entry that gains its arguments and its outcome as it runs (✓ Bash · 3.6s pytest tests/test_render.py, ⟳ Edit …/style.css), plus a quiet narration line of what the model is saying as it works and a thinking pulse for the silent stretches. It is display only: the answer is still reconstructed from the final result. Both the local runner and the paired leaser carry it.

1.17.0 (2026-07-13)

• The hosted workspace pings you again. The whole point of yothere is that you do not babysit the fleet: it works, and it comes and gets you when a thread needs a human. On the hosted workspace that had quietly stopped being true, because your machine runs the turns and the control plane was not notifying out. So the bell was hidden, and if you closed the tab, nothing reached you: the thread just sat in the Inbox until you remembered to look. The control plane now runs that sweep itself, per workspace. Turn the bell on in the cockpit and a push lands on your phone when a thread needs you, deep-linking to the one decision. One coalesced nudge, rate-limited, quiet overnight, and a thread you have already answered never pings you twice.

1.16.0 (2026-07-13)

• Running out of steps is no longer a failed task. A long task that used up its per-turn step budget used to stop and ask you to continue it. That was a cliff, and any number would have been a cliff: the task had not failed, it had simply run out of room inside one subprocess, and the thread model is already multi-turn. It now continues on the next turn with no human in the loop. The wall-clock timeout behaves the same way, and it now honours a result that already landed. A genuine crash still stops, because “ran out of room” and “died” are different things and only the first is safe to retry.

1.15.0 (2026-07-13)

The honesty release. Three bugs, one theme: yothere knew the answer and told you something else.

• A finished task no longer comes back as a failure. A worker would do the work, write its result, and then the agent CLI would exit non-zero on the way out (it does that whenever the final frame carries an error, including hitting the turn cap or a usage-limit 429, and both of those fire after the model has already answered). yothere read the exit code, stamped the thread stuck, and buried the real answer underneath. Only big tasks ever hit it, because only a big task burns through the turn cap after writing its summary. That is the whole of “bigger tasks get confused”. The rule now: the worker’s own status is the authority on what happened, and the exit code is not.
• A usage cap now holds and retries instead of wedging. The hold existed, but it was reachable only from a local runner, so every hosted 429 turned into a permanent stuck.
• A task that outlives its turn is delivered, not just filed. On a voice call, a long task used to pass its deferral window and freeze: the result reached your Inbox but never your ear, and “I’ll report back the moment it lands” was a promise no code path could keep. A watcher now puts the thread back on the delivery path.
• A failed turn leaves forensics behind. A failed hosted turn used to leave nothing to debug with: the leaser deleted the working mirror (taking the log with it) and the one field that survived was reliably empty. The final frame and the failed turn’s log are now kept.

1.14.0 (2026-07-12)

• Your threads can run on the Codex CLI. A ChatGPT subscription is now a complete answer to “what agent runs my work”, not a reason you cannot use the product. Pick the backend per thread with harness: codex in brains.yaml, or fleet-wide with YOTHERE_THREAD_HARNESS=codex. It is a peer of the Claude Code path, not a lesser mode: the same containment, the same approve-send grant, the same streamed progress on the work card, the same resume across turns, the same cost ledger and caps. Auth is a one-time codex login into a Codex home that yothere owns, never an API key, and yothere never touches your own ~/.codex.
• yothere doctor and yothere init know codex. They resolve the binary (Codex.app keeps it inside the app bundle, so it is usually not on your PATH), probe its version, and tell you when the codex home has no auth yet, naming the one command that fixes it.
• The send gate is verified on codex, not assumed. Codex silently skips a hook it does not trust, which would leave a turn ungated while every log line claimed otherwise. So a codex turn that ran shell commands without the gate ever firing is failed closed: later turns drop to a read-only sandbox until yothere doctor proves the gate again.
• Honest caveat: codex cost is an estimate. Codex reports tokens, not dollars, so yothere prices them from a built-in table that is a point-in-time snapshot, and an unknown model bills at the most expensive row. On a subscription the true marginal cost of a turn is zero until you hit the plan’s usage limit, so read the number as a runaway-loop stopper rather than an invoice.

1.13.2 (2026-07-11)

• A pairing block a security-minded agent can audit and pass. The block now states its own limits instead of over-claiming them: the send gate stops outward sends, but reads run uncontained, and a plain GET can carry data out. For a machine that holds live credentials there is a scoped-pairing recipe (a work directory plus a stricter permission mode). The security page was rewritten to agree with the block, and the sdist-audit command pins the interpreter so your agent audits the code it will actually run, not a months-old release.
• yothere --version. The first command an auditor types now answers instead of erroring.
• No token burned on a machine that is already paired. The block leads with yothere doctor, and the Connect panel says when the machine is already connected.

1.13.1 (2026-07-11)

• Copy for your agent. The pairing block exists to be pasted into a coding agent, so minting a token now hands you a real clipboard button (with a select-the-text fallback where the clipboard is unavailable) and tucks the block behind a “Show the block” toggle.
• The pairing panel fits on screen. The card is now bounded and the block scrolls inside it, so Pair and Close stay clickable instead of being pushed past the bottom of the viewport.

1.13.0 (2026-07-11)

• Fast-lane chat. A question typed into a thread used to pay for the full long-running-work contract (read the plan, write status, heartbeat) before it answered. It now answers at parity with a bare claude -p (2.9s versus 3.0s on a zero-tool question, 4.8s versus 14.2s on a lookup), while real work keeps the full cockpit contract byte for byte. A classifier decides which is which, and any doubt is work: a voice reply, a plan review, a pending send approval, a first turn, or anything long or multi-line all stay on the contract.
• A question never queues behind long work. Chat draws from its own capacity slots and is served first. Work concurrency went from 3 to 5.
• Live progress on the work card. A turn streams its tool activity as it runs, so a four-minute turn stops sitting behind “running, no progress reported yet”. The same signal doubles as a lease heartbeat, which fixes a long-running turn being re-leased and re-run underneath itself.
• Replies come back on the edge. Dispatch, reply, and result now wake the job queue and the live stream instead of waiting on a fixed tick, so a reply no longer pays a tick on the way in and another on the way out.

1.12.0 (2026-07-11)

• The per-thread cost cap is now $10, and you can tune it. The old $1.50 cap sat below the cost of a single real agentic turn, so threads capped almost immediately. Set it with YOTHERE_PER_THREAD_CAP_USD, mirroring the daily fleet cap YOTHERE_DAILY_COST_CAP_USD.
• A capped thread comes back and asks you. It used to freeze silently and become permanently unanswerable, sitting in the Inbox forever with no explanation. It now returns as an answerable card (“Continue, raise the cap, or stop?”), “raise the cap” actually raises that thread’s own ceiling, and Discard closes the thread without needing the very worker turn the cap was blocking. A cancel must never depend on the thing being cancelled.
• Over-cap threads no longer starve your queue. They used to win every capacity slot on every poll and then get dropped, so nothing affordable got leased at all. Capacity is now allocated only to threads that can still run.
• Transactional email sends from production again. Every welcome, verification, reset, and invite email was being rejected at the edge before it reached the mail provider.

1.11.1 (2026-07-10)

• One spoken request is one dispatch. “Send a message to someone about X” used to fan out into two threads, one composing and one sending. A single action and everything it needs (one recipient, one message, its content and context) is now one dispatch.
• A calmer voice. The “still working on it” status line now waits for a real pause instead of filling every gap, and the agent finishes the answer it is giving before it announces a task that just finished.

1.11.0 (2026-07-10)

• Connect tells you what it is doing. Clicking Connect now shows an instant staged status (“Requesting microphone”, “Connecting”, “Waiting for yothere to speak”) that clears the moment the agent is actually audible, so a hosted cold start is no longer a silent wait behind a button that says “connected”.
• The greeting opens with the brand word. yothere says its own name first.
• Dead chrome removed. The permanently disabled mic button is gone from the command bar, and the push bell only appears where a push can actually be delivered.

1.10.0 (2026-07-10)

• Walk your Inbox by voice. A voice session can now read the open Inbox and act on it, one item at a time: it reads an item, waits for your verdict, then replies or dismisses. It can never answer or dismiss an item you have not addressed, a spoken approval still has to be unambiguous to mint a send grant, and a call whose control plane is unreachable says the inbox is unavailable rather than crashing. The greeting opens with the count of items waiting, never a listing.
• A bridge health check is not a send. A pre-draft health probe used to consume the single-use send grant, so the approved send that followed it was denied. The probe is now exempt and never spends the grant. Real sends keep the ordinary deny.
• Every inbox card can be dismissed. Question and informational cards now carry the same Dismiss affordance the others had.
• Two different voice tasks no longer collapse into one thread. Dispatch dedup was comparing tasks after a fixed block had been stamped onto both, making dissimilar work look identical.

1.9.0 (2026-07-10)

• Account settings in the hosted cockpit. The gear now opens /settings: change your password (current password required, every other session signed out, the one you are using survives), see your paired machines and revoke any of them in one click, sign out everywhere else, or log out.
• Self-serve account deletion. The danger zone takes an exact confirm phrase plus your password, then deletes every account row (user, sessions, device tokens, login history, pairing tokens) in one transaction and purges your voice rows. Your workspace home is archived by rename for a grace window rather than destroyed, and the server-side event rows keyed to your tenant are not purged. It is a deletion, not a full erasure: Privacy spells out exactly what goes and what stays.
• A spoken approval lands on the draft it approves. An approval-shaped utterance that arrives as a fresh request is now routed into the blocked draft it refers to, instead of spawning a context-free thread the send gate then blocks. The classifier is deliberately narrow: partial approvals (“yes but change the greeting”), questions (“did you send it”), and deferrals (“send it after lunch”) stay unclear and re-ask rather than releasing an old draft.
• Voice answers from your real task source. “What are my open tasks” on a call reads the task cache the cockpit shows, refreshes it when it is stale, and states the age of a list older than 24 hours instead of reading it as fresh.
• Barge-in actually interrupts. Voice tuning for echo-cancelled browser mics, so talking over the agent stops it. Asked about its own instructions or tool list, the assistant deflects in one line instead of reciting them.

1.8.0 (2026-07-10)

• Pairing is single-use by construction. “Connect a machine” mints a short-lived pairing token (60-minute expiry, stored only as a sha256 hash) rather than a directly usable credential. yothere login exchanges it for a fresh per-device credential, and the pairing token is consumed atomically at that moment: a second claim, an expired token, or an unknown token all get an honest error. The block your coding agent reads was rewritten around checkable facts, with an sdist-audit path, the four files worth auditing, and a plain statement of the token’s lifecycle.
• Unattended work needs your explicit consent. yothere service refuses to start the leaser when the worker would run in bypass posture with no recorded consent. It prints the consent text and the exact one-line acknowledgement, which also works from an env file or a service unit.
• Tell us what is broken from inside the product. A feedback button in the cockpit header, and yothere feedback "<text>" from any paired machine.
• Transactional email. Self-serve password reset (single-use 45-minute links, an identical response whether or not the account exists, and a successful reset signs out every live session), a signup welcome with an optional verification link, invite codes delivered by email, and a once-per-day notice when a budget cap blocks work.
• A tasks strip you can walk. “Go task by task” opens a stepper, one card per task, most urgent first: Delegate hands it to an agent with the command bar prefilled, Done marks it complete at its source without spending a turn on delegation, Skip advances. Typed intents like “what’s my most important task” and “what’s next” answer straight from the cached strip without spawning anything.

1.7.0 (2026-07-09)

• Approve a send with your voice, end to end. On a live voice call, a worker drafts an outbound message and yothere reads the draft back to you. Say yes and your spoken approval releases the send into the very thread that was blocked and waiting, so “speak it, hear it, confirm it, it goes” now works start to finish. The approval is read strictly: anything hedged or ambiguous is treated as “not yet” and nothing leaves until you are clear.
• Install the paired machine as an always-on service. yothere service install turns the machine that leases and runs your jobs into a background service that starts on boot and restarts itself if it stops, on both macOS (launchd) and Linux (systemd). It checks the things that matter at install time (machine paired, the claude CLI on your PATH, a work directory set) so it does not fail silently later. Plain yothere service still runs the same loop in the foreground when you want to watch it.
• Cancel a queued job from the cockpit. A job waiting in the queue now has a Cancel chip, so you can park and archive it without opening a terminal. A job that is already running mid-turn is left alone.

1.6.0 (2026-07-09)

• Start work from your own tasks. “From your tasks” is now real in the hosted cockpit. Discovering, refreshing, and writing back your tasks is work that runs on your own paired machine, leased out over the same jobs channel your agent turns already use, so the cockpit shows honest “queued, waiting for your machine” and “discovering” states while it happens.
• A clearer task lifecycle. Finished threads now land in Past instead of bouncing back to your inbox, and a thread has to name the outcome it actually carried out before it counts as done. You can also accept or archive a thread without spending a turn on it.
• A faster, steadier hosted control plane. The hosted workspace now shares one database connection pool across its stores and moves its heavier scan work off the main loop, so one busy tenant’s polling no longer slows the cockpit for everyone else.

1.5.8 (2026-07-08)

• Pairing instructions a coding agent can trust. The Connect-a-machine panel now spells out exactly what it is asking you (or your coding agent) to run: links back to the package and this site, a pinned install line, a plain statement of what the device token can and cannot do, and no false urgency. A security-minded agent can read it, verify it, and run it instead of refusing it as phishing-shaped.
• The relay-to-yothere rename is finished. The old relay command is gone; yothere (and yothere-mcp) is the CLI. Env names, service labels, and log lines no longer say “relay”, though the legacy RELAY_* variables still resolve as deprecated aliases.

1.5.7 (2026-07-07)

• Deterministic installs. Python support is now explicitly 3.11-3.13, and the [voice] extra pins a known-good WebRTC stack (pipecat, aiortc, av/opencv as a matched pair). A fresh install resolves the same way every time instead of playing dependency roulette.
• yothere doctor. One command to verify an install: Python range, pinned-dependency drift, and a WebRTC loopback self-check, plus yothere doctor --bundle for a redacted diagnostics bundle you can attach to a bug report.
• Cross-NAT voice calls fixed. Calls between a browser and a paired machine on different networks no longer fail against the TURN relay; the answerer now binds only to publicly routable candidates and the browser defaults to relay when TURN is available.
• Agent-ready pairing. The Connect-a-machine panel emits a copy-paste block you can hand to your coding agent verbatim: provenance links to PyPI and yothere.ai/trust, the BYO-compute trust model, the Python 3.11-3.13 requirement, and a one-time device token you can revoke with yothere devices revoke.

1.5.6 (2026-07-06)

• Voice from the cockpit. Talk to your fleet over a live voice call from the browser. At this release the signaling ran through the hosted control plane and the call media ran on your own paired machine. Voice has since moved to the hosted media plane: today you click Connect and the call runs on our side, with nothing to install. See Privacy for what a call stores.
• Bring-your-own-compute, hardened. Pair a machine with yothere login, then yothere service leases jobs from the hosted control plane and advances them locally. A preflight now fails fast with a clear message when the claude CLI is missing, instead of hot-looping.
• Manage your machines. New yothere devices list and yothere devices revoke <id> to see and de-authorize paired machines from any other machine.
• Safer multi-tenant. Per-tenant rate limits, tenant-scoped job leases, and a housekeeping tick that expires stale leases and auto-parks unanswered asks across every workspace.
• Home rename finished. Per-tenant homes moved from .relay-<tenant> to .yothere-<tenant>, migrated automatically on first use.

1.5.2 (2026-07-04)

• First public PyPI release. yothere now installs straight from PyPI (pipx install yothere). Earlier builds shipped as GitHub release wheels; publishing now runs through PyPI trusted publishing.
• Private-data scrub. Shipped code comments and prompts were genericized so the public package carries no personal data.
• Installable PWA. Add yothere to your phone’s home screen and clear the inbox from anywhere. Web push ships with the local runner; on the hosted workspace the opt-in stays hidden, because proactive pings from the hosted control plane are not wired up yet.
• Hardened hosted mode. Signup rate-limiting, a work-directory TCC guard that refuses macOS paths a background worker cannot read, and an env/cookie naming cleanup for multi-tenant deploys.

1.5.1 (2026-07-03)

• Rename from Relay to yothere is complete. The package, module, CLI command, and PyPI distribution are all yothere. yothere is the canonical command and relay stays as a deprecated alias, so old scripts keep working. The default home is now ~/.yothere (an existing ~/.relay is still honored as a fallback). YOTHERE_* is the going-forward environment namespace, and every legacy RELAY_* name still resolves.
• Version integrity fixed. The installed package now self-reports the same version as its release tag; an earlier wheel mis-reported its version.
• Zero-key first run. yothere init creates the home layout and detects an existing brain, and yothere init --demo drives one thread end to end (blocked to reply to done) with no API key.
• Safer worker default. Local Claude worker turns now run under a permission bypass contained by a send-gate that denies outward sends (mail, git push, HTTP requests with a body, MCP send tools) while leaving plain reads allowed. You can opt out in configuration.