Personal loop

View as Markdown

Everything Yield does for you alone: what it captures, how to find and continue your own earlier work on any computer or agent, and how to keep a folder or an hour out of it. None of it is visible to anyone else.

What is captured

On each computer where you ran yield login, the capture service reads Claude Code’s and Codex’s session files as they are written and sends every line to your personal Tonbo account, as written. After each turn in a git repository it also snapshots the repository’s files (as git add -A would see them, without touching your index, branches or history; files over 100 MiB are left out). A session outside any git repository is captured without snapshots.

While Tonbo cannot be reached, the session files themselves are the queue: capture resumes where it stopped and sends nothing twice.

yield status          # the one health view; each problem names its fix
yield daemon status   # the capture service alone
yield devices         # your computers, and which are online

See what is running

yield ps lists your sessions on every computer: whether each is waiting on you, running, idle or ended, since when, the agent, the repository, and the files it wrote lately. Ended sessions are left out unless you add --all. Above them, under NEEDS YOU, it lists what waits on you, each with the one command that resolves it: a handoff named to you or a run that needs you, a session waiting for your answer, a result to pull, and two of your live sessions that wrote the same file.

Continue earlier work

Describe the work in your own words. yield continue ranks your sessions of the last 30 days by their title, files, prompts and final messages, lists the best three, and picks up the first:

yield continue "the refund webhook"

On the computer that captured it, it names the session’s folder, where you carry on. Elsewhere it restores the session’s latest snapshot into a new directory and prints its last turns. Add --pick 2 to take the second candidate instead.

Hand off to another computer or agent

A handoff is an explicit link, for when you know where the work goes next. In a repository connected to a personal Project (yield connect), bare yield hands off the live session:

yield --task "add the retry test" --to claude-code   # you, in Claude Code
yield --task "add the retry test"                     # you, anywhere

It captures the session up to now, pins a snapshot of the folder for 30 days, and prints https://tonbo.dev/y/<id>. Take it where you continue, inside a clone of the same repository, with yield take <link>. In the restored directory, yield done "<result>" publishes the result, or yield need-human "<why>" marks that it waits on you. Back in the original, yield pull <link> fetches the result onto a branch (--patch writes a patch file instead) without changing your files.

yield handoffs lists the handoffs still open, yield show <link> prints one without taking it, yield renew <link> keeps its snapshot 30 more days, and yield cancel <link> withdraws one nobody has taken.

Run it on another of your computers

yield --task "add the retry test" --to mac-2:codex

In a personal Project, --to <device>:<harness> sends the handoff to another of your own computers instead of waiting for a yield take: yield devices marks the ones that can take it, online and with that agent. Its capture service restores the snapshot into a fresh folder and runs Claude Code or Codex there unattended, in the agent’s default permission mode, allowed to edit files in that folder, run tests and read. A push, a delete or anything else stops the run and the handoff waits on you. Your inbox tells you when it is done (yield pull <link>) or needs you, and yield show <link> says what stopped it and how to resume it there. Only your own computers can be targets, and Yield never handles the agent’s model credentials.

Recall a file’s history

In a repository, yield why <path> answers why a file is the way it is: the turns that changed it with their prompts, the agent’s summaries and the other files each turn changed. yield files <path> is the bare list with each turn’s snapshot. yield session read <id> prints a session as user:, assistant: and tool: lines, and --turn <n> only one turn.

A change marked indirect happened in the repository during that turn without that session writing it, such as another session working in the same folder.

The inbox

The capture service keeps messages for you on each computer: a handoff that names you or is open to your team, one you gave being taken, finished, failed, returned or waiting on you, and two of your sessions writing the same file within two hours, on this computer or in the same Project on another of yours (lockfiles and generated files never count). yield inbox lists the unread ones. Only the ones that need you or carry a result raise a system notification, which yield inbox mute stops. yield inbox ack marks them read. In Claude Code, new messages also reach the session itself (Agent guide).

Keep things out of capture

yield pause --for 2h      # nothing written in the next two hours is captured
yield resume
yield exclude ~/clients/acme   # never capture sessions in this folder
yield include ~/clients/acme

What is written while paused is never captured, also after you resume. A session in an excluded folder sends nothing, not even that it started. Both settings stay on the computer, and yield status shows them. What was captured before stays as it is: the Alpha has no command to delete a captured session.