yothere

Quickstart

From a fresh machine to a fleet of agents working on it, in six steps.

Beta · signup open

yothere is in open beta. Create your workspace at app.yothere.ai/signup, your first 7 days are free, no credit card. Then the Founding plan is $20/mo.

Six steps, in order: install, pair, point the workers at a directory, start the leaser, hail a task, reply when one comes back. Nothing here is optional and nothing here is out of order.

Before you start

You need all four of these before the first command. yothere is a cockpit, not a model: it never holds your model credentials and never bills you for inference.

  • A Mac or Linux machine you can leave open. Windows needs WSL2.
  • Python 3.11, 3.12, or 3.13. Not 3.14.
  • pipx.
  • Your own Claude Code or Codex CLI login, already working on that machine.
Leave the laptop open. Every agent turn runs on your paired machine. The hosted control plane runs no agent compute at all. While your machine is asleep or closed, dispatched threads sit in the queue and drain the moment it reconnects. Nothing is lost, and nothing advances either.

1. Install

pipx install yothere

Check the machine before you go further. doctor reports pass, warn, or fail per check, with the fix for each one:

yothere doctor

Full options and extras are on the Install page.

2. Pair this machine

Sign up at app.yothere.ai. The first 7 days are free, no credit card. Then, on the machine that should do the work, run:

yothere login

It prints a short pairing code (rendered XXXX-XXXX) plus a link to app.yothere.ai/activate. Open that link in the browser where you are already logged in, see which machine is asking, and pick its permission tier (read-only, workspace, or full; the full tier ticks a bypass-consent checkbox). The CLI polls and saves a long-lived per-device credential at ~/.yothere/credentials.json with 0600 permissions. No token is pasted, and your coding agent never handles a secret. Your Claude or Codex login never leaves the machine, and we never see it.

--url defaults to https://app.yothere.ai, so you only pass it for a self-hosted control plane. An optional --label names the machine.

Headless or SSH-only box with no browser. The device flow covers it: run yothere login on the box and open the printed /activate link in a browser on any device, your laptop or your phone. For unattended provisioning, an operator can mint a single-use token on the control plane with yothere admin pair-token, then:
yothere login --url https://app.yothere.ai --token <operator-minted-token>

A worker turn runs the agent CLI headlessly, without a per-action prompt for every file it reads or command it runs, scoped to one working directory. That is the whole point, and it is also the thing you should agree to on purpose. yothere refuses to start the leaser until you have.

The working directory is the turn’s cwd. Either run the leaser from that directory, or set it explicitly:

export YOTHERE_WORK_DIR=~/code/acme
export YOTHERE_BYPASS_PERMISSIONS_ACK=1
Not under ~/Documents or ~/Desktop on macOS. A launchd worker cannot read those directories (macOS TCC blocks it) and will crash-loop. Pick a directory outside both.

To make this permanent, record both keys in ~/.yothere/yothere.env, which the always-on unit in step 4 sources on every start. The cockpit’s onboarding checklist writes that file for you.

4. Start the leaser

This is the process that leases queued threads from the cockpit and runs each turn on your machine. In the foreground, to watch it:

yothere service

It advances up to five work turns in parallel by default (--workers), plus a separate pool for your typed replies (--chat-workers), so answering one agent never queues behind the other four.

When it looks right, install it as an always-on unit (launchd on macOS, systemd on Linux) so it survives logout and reboot:

yothere service install
yothere service status

The call itself is hosted and needs nothing installed here. The unit is what gives the work a machine to run on when you are away from the terminal, whether you dispatched it by voice, from your phone, or from the cockpit. install refuses to run until the machine is paired, and it touches only the leaser unit.

5. Hail your first task

Type it in the cockpit, or say it out loud with Connect. One line is enough:

scan our top 3 competitors

The thread is queued, your machine leases it, and it starts working. Hail three more while the first one runs. That is the entire point:

research the SOC 2 options and compare them
draft replies for the support inbox
review the vendor contract and flag what's unusual

From the CLI, the hail is the argument to spawn. There is no yothere scan and no yothere research: every hail goes through one command.

yothere spawn "scan our top 3 competitors"
Note ship, merge, deploy and push are not task words, and yothere will refuse to spawn a thread from them. They are the words you say to approve work that already exists ("send it", "ship it"). That is deliberate and permanent.

6. Watch it, and reply

Open app.yothere.ai/overview. Three lanes: an Inbox of what needs a human, a Working lane of what is in flight (each card says what its turn is doing right now), and a Done pile.

Four kinds of card can reach the Inbox: a question (it hit a fork), a draft to send (you press Send), a plan to approve (it wrote the approach before doing the work), or a result to look at. Everything else advances silently, and running out of steps is not a failure: the thread just takes another turn.

Reply from the card, and the fleet moves again. Install the cockpit as an app on your phone and turn the bell on, and a push will deep-link you straight to the one thread that blocked.

Work in one of your repos

Register a repo you already have on this machine. yothere never clones, and it never holds a git credential:

yothere workspace add site ~/code/acme-site
yothere workspace list

Then bind a hail to it. Code verbs (fix, add, implement, refactor, and the rest) are real hails:

yothere spawn --repo site "fix the layout shift on the pricing page"

That thread’s turns run in their own git worktree, under ~/.yothere/worktrees/, so a code thread never touches your working tree and two threads never collide. It commits to a branch named yothere/<thread-id>-<slug> and ends with the diff, for you to read. Press Ship it and yothere pushes that branch and opens the PR as you.

The agent cannot push. You can. git push and gh are on a never-grant list no approval can open, so a worker turn can never publish. Pressing Ship it does publish: the push and the PR run host-side as you, outside the turn, as plain git with no model in the loop. The worktree isolates threads from each other; it is not a sandbox, so it does not contain what a turn reads or writes elsewhere on the box. See Trust.

The local demo, with no account and no keys

To see the whole loop (spawn, work, blocked, reply, done) on your own machine before any of the above, run the bundled demo brain:

yothere init --demo

It starts a zero-key demo brain on localhost, spawns one thread, and drives it through the real runner-to-worker-to-brain path in about 30 seconds. You watch it stream progress, go blocked to ask for your judgment, take your reply, and finish done.

The local path has its own commands. Threads spawned this way live on this machine and are advanced by the local runner, not by the hosted queue:

yothere init                                  # create ~/.yothere, detect your agent CLI
yothere spawn "scan our top 3 competitors"    # create a thread (does not advance it)
python -m yothere.runner loop                 # advance the fleet locally
yothere list                                  # a table of live threads and their state
yothere show <id>                             # one thread in detail
yothere reply <id> "yes, go ahead"            # answer a blocked thread
yothere board --open                          # a standalone board in your browser

yothere spawn takes --focus (pin it as the focus thread), --mode auto|planning (skip the automatic scope classification), and --yes (spawn anyway on a low-confidence parse). If your text reads as a reminder (“remind me to …”), yothere captures it as a note instead of spawning a thread. Use yothere note "<text>" to do that on purpose.

Not yet, and we will say so

Coming soon: recurring tasks. A hail runs once, immediately. There is no scheduler in the product today, so "every morning at 7, scan the news" spawns a single thread that runs right now. It is not built yet, and it is not on sale.

Next steps

  • Onboarding: the same path with the cockpit’s checklist walking each step.
  • CLI reference: every command and flag.
  • Configuration: every YOTHERE_* environment seam.
  • Trust: what the send-gate holds, and the boundary it does not.
  • Agent onboarding: the machine-readable version of this page.

New to the ideas behind the loop? Read Core concepts first.