Yardsort

Orchestrate any coding agent — on Linux, macOS and Windows.

Open-source desktop for Claude Code, Codex and any CLI agent you already use. Parallel tasks get their own git worktrees; several agents can share one. Hand the work to the next agent with the context Yardsort already recorded — no re-explaining the branch. Agents can read what the others said, and write smoke tests that Yardsort runs.

yardsort.sh · Download · Quick start · Documentation · Contributing · Contact

CI License: GPL-3.0 Latest release

![Yardsort: projects and workspaces on the left, an agent's terminal in the middle, its changes and a diff on the right](docs/images/overview.png) ## What it is A sorting yard is where rail cars are sorted onto parallel tracks and later joined back into one train. That is the job: fan work out onto parallel branches, then merge it back — and hand a car from one crew to another without retelling the whole journey. You describe a task, pick an agent, and press Enter. Yardsort creates a branch and a **git worktree** for it — a separate folder — and starts the agent there in a real terminal. Start another task on another track, or start a second agent in the same worktree. **Hand off** writes the next agent a first message from what happened here: your task, the branch, who wrote each file, what every run did. Project memory carries the short lessons you approved. On the right you watch the files each one touches, live, with diffs. An agent started beside another can read what that one was asked and answered, and a smoke test an agent wrote checks the result step by step. It is modeled on tools like Conductor and Superset, with the requirement they do not meet: **Linux, macOS and Windows are all first-class**, built and tested together on every change. ## Highlights - **Track tokens and machine resources.** Open **Usage** from the sidebar to compare Claude Code, Codex and Grok by day, model and workspace, see estimated API costs and Codex's last reported plan limits, or inspect live CPU and memory for every terminal's process tree. [More below](#usage-tokens-cost-estimates-and-machine-resources). - **Keyboard navigation you can configure.** A command palette, panel focus and workspace/tab switching, with an in-app [shortcut cheat sheet and editor](docs/guide/shortcuts.md). - **A guided first look.** An optional welcome tour explains the main panels; replay it from Help / Tour any time. - **Any terminal agent.** Claude Code, Codex, Grok, OpenCode, OMP, Cursor and Pi [out of the box](#supported-agents); add any other with a few lines of configuration — no plugin, no release to wait for. - **The terminal is the truth.** Agents run in a real PTY with their own interface. Whatever they can do in your terminal, they can do here — and Yardsort never parses their output. - **Plain git, no lock-in.** Workspaces are ordinary worktrees and branches. Inspect or undo anything with `git`. Worktrees made elsewhere can be imported, and never appear uninvited. - **Closing the window doesn't stop them.** Terminals live in a small background process, so agents keep working while Yardsort is closed — or after it crashes. Open it again and every screen is repainted where it got to. Closing with work in flight asks first. - **Pick up where you left off.** For conversations that really did end, press **Resume** — it is intact. **Fork** one to try a different approach without losing the first. - **Hand the work to another agent.** One click writes the next agent's first message from what Yardsort recorded — your task, where the branch stands, who wrote each file, what every agent run did and what is not known — for you to read and edit before it goes. Codex after Claude, without retyping the story. [More below](#hand-the-work-to-another-agent). - **Agents that know what the others said.** An agent started in a workspace where another has been working is told so, and `ys workspace context` reads it what you typed and each turn's reply, from the agents' own transcripts, without tool output. Every built-in agent can be read, nothing is stored, and a project can turn it off, since what an agent reads goes to its provider. [More below](#shared-conversations-agents-that-know-what-the-others-said). - **Build on work in progress.** **Fork into new workspace…** starts a new branch from a workspace's branch, in a worktree of its own, and tells the new agent what was recorded about the one you forked. [More below](#hand-the-work-to-another-agent). - **Workflows: named agent work, in steps.** A short YAML file — have a second agent review this pull request, then tell me and the agent that wrote it — run from the sidebar or with `ys workflow run`, its steps drawn as a chart, every mistake named at its line. The built-in code review is one click in a workspace's menu. Describe one in your own words and a model writes the file, for you to check and save. [More below](#workflows-named-agent-work-in-steps). - **Smoke tests: the ten-minute check, repeatable.** The steps a person runs by hand before saying "done" — start the server, open a page, click, look for a word — written as a YAML file in your repository, that an agent writes and Yardsort runs, step by step, with every output, screenshot and reason for a failure kept. **Tests**, in the sidebar, lists every test and every run. A file from a repository never runs until you have seen it. [More below](#smoke-tests-the-ten-minute-check-repeatable). - **Schedules: at a set time, or on a routine.** Run a workflow or a smoke test once at a time you pick, or again and again — every weekday at nine, every two hours, a cron expression — in a workspace you already have, or for a workflow in a new one made for each run, while Yardsort is open. A notification tells you when a run fails. [Schedules](docs/guide/schedules.md). - **Triggers: when something happens.** Start a workflow or a smoke test when an agent says its work is done, someone reviews the pull request, its checks fail, a run ends, or something you name happens. Ready-made ones — address reviews, fix failing checks, review or smoke test the work when it is done — are a box to tick when you start a workspace. A cap per pull request, an hourly limit and a limit on chains keep a trigger from looping. [More below](#triggers-when-something-happens). - **See what happened.** Live list of changed files, character-level diffs, a file tree, and image previews. Edit text files inside Yardsort, with retained drafts and a check before overwriting a file changed on disk, or open them in your editor. With an agent reporting, each changed file says who wrote it: an agent that reported writing it, one that was running a command when it was last written, or nobody the record knows of. - **Send it on without leaving.** Commit what an agent wrote, push it, and open the pull request from the panel you reviewed it in — the title written from the commits. With the [GitHub CLI](https://cli.github.com) the pull request opens from here and its number and check results appear on the workspace row, with any others the workspace opened beside it — those opened in other repositories too, like the nested clones of a parent project, once Yardsort sees an agent open one or an agent or you track it; one that conflicts with its base can be handed back to the agent that opened it to resolve. Without `gh`, your browser opens the forge's own form, on GitHub, GitLab, Bitbucket or Gitea alike. See [Commits & pull requests](docs/guide/commits-and-pull-requests.md). - **Every pull request in one place.** **Pull requests**, at the top of the sidebar, lists the pull requests of every project on GitHub — yours, a teammate's, an agent's — with their checks, reviewers and size, filtered by project, author and review status. Open one to read its description, its checks, the conversation and its diff, with every comment beside the lines it is about; reply, or select lines and send a note about them to the agent working on it. Start a workspace on one, merge it, close it or reopen it from there, each confirmed first and naming whose it is. A pull request an agent opens in another repository — a nested clone of a parent project — is listed too, with the workspace it came from, and is merged, replied to, read and [reviewed](docs/guide/workflows.md#a-pull-request-in-another-repository) the same way. It reads GitHub through `gh`; Yardsort still holds no credential. [More below](#every-pull-request-in-one-place). - **Your issues, where the agents are.** **Tasks**, in the sidebar, lists every project's open GitHub issues and counts the ones that need an answer — where the last person to speak was not a maintainer. Open one to read it, then **Delegate**: the composer opens with the issue as the agent's first message, marked as text other people wrote, and nothing starts until you say so. The workspace remembers the task it came from. Open a new task, answer one, close, label and assign it from the same view. `ys task` does all of it from a terminal, so an agent can tell you what is open and file an issue when you ask. Everything goes through `gh`. [More below](#your-issues-where-the-agents-are). - **One agent that sees everything.** The [Floor Manager](docs/guide/floor-manager.md), in the bottom bar's corner or **Mod+J**, is an agent you pick that has every project in view through `ys`. Ask what is running, which pull requests nobody has reviewed or which need attention, or to start a task. It suggests a workflow, opens workspaces on other people's pull requests and starts reviewers on them. How much it may do on its own is a setting: read only, ask first (the default) or trusted. `ys` enforces it. Deleting a workspace, closing a task and attaching stay refused. A shell command that is not `ys` is outside that gate. - **Start from a repository or a link.** **Clone a repository** lists the repositories your `gh` account owns or collaborates on — type to narrow, pick one, clone — or takes a clone URL from GitHub, GitLab, Bitbucket, Gitea, Forgejo or a host of your own. **Start from a link…** takes an issue's or a pull request's address and opens it, ready to delegate; a repository that is not a project yet is cloned on the way. See [Projects](docs/guide/projects.md#clone-a-repository). - **Know who needs you.** Status dots show which agents are working and which are waiting; a desktop notification tells you when one finishes while you are elsewhere, and [Notifications](docs/guide/notifications.md) lists, over every project, what waits for you and what finished while you were not looking: agents that ask for a permission or are done, workflows waiting for an approval or an answer, smoke tests waiting to be let run, and schedules and triggers that could not start. Other computers you reach are in the same list. - **Careful with your work.** Deleting or archiving a workspace always keeps the branch, and never discards uncommitted changes without a second, explicit confirmation. - **A second pair of eyes, if you want one.** [Assist](docs/guide/assist.md) asks [Jev](https://docs.typesafe.ai), TypeSafe's judgment model, small typed questions about each changed diff, and badges the files that look unrelated to the task, or that add a secret, weaken a test or switch a check off. It can also suggest a harness and an effort for the message you are typing. Off unless you bring your own TypeSafe API key — see [below](#assist-judgment-from-jev-if-you-want-it). - **Private by construction.** No account, no telemetry, no keys of ours. Agents use their own logins; Yardsort just starts them. It talks to the network to check for new versions, which you can switch off — and, only if you switch Assist on and add your own key, to ask Jev about your diffs, or, only if you turn on [Remote](docs/guide/remote.md), to the server you choose. - **A record of what ran.** Yardsort keeps a local note of when each agent started in a workspace and how it ended — even if it ended while the window was closed — without reading a word the agent printed. Turn it on, and every built-in agent — Claude Code, Codex, OpenCode, Grok, OMP, pi and Cursor — reports its own tool calls, file changes and turns to the same record, as metadata, with its own settings untouched. An experimental timeline shows it; `ys activity export` writes it out. See [Activity](docs/guide/activity.md). - **Project memory, approved by you.** Short lessons about a project for its agents — "the tests need `TZ=UTC`". You write them; agents propose them with `ys memory propose`, and those wait for you. Only what you approve reaches an agent: after its first message, cited, and in handoffs — unless you turn that off for the project. See [Memory](docs/guide/memory.md). - **Outcomes, in your words.** After you archive or delete a workspace, one optional click says how it went; a merged pull request counts as kept until you say otherwise. Each agent's history on your own work sits beside the composer's picker — and says "too few to say" until there is enough of it. See [Outcomes](docs/guide/outcomes.md). - **Choose how agents start.** Enable **Always start in auto mode** per harness in [Settings](docs/guide/settings.md#auto-mode). For Claude Code and Codex, with activity capture enabled, a [context hint](docs/guide/terminals-and-sessions.md#when-an-agents-context-fills-up) offers **Compact** when a conversation reaches 80 % of its context window. - **Keeps itself current.** Signed in-app updates on macOS, Windows and the Linux AppImage — one click, and your agents' conversations resume afterwards. - **Scriptable.** [`ys`](docs/guide/cli.md), a small command-line client that comes with the app, starts a workspace and an agent without opening the window: `ys workspace new ""`. The agent belongs to the background process, so it carries on after the command returns — and `ys attach` puts it back on your terminal, `ys logs` prints what a session ended up with, `ys workspace handoff` prints the next agent's first message, `ys workspace fork` starts the next feature on a new branch from a workspace's, `ys workspace context` prints what its other agents were asked and answered, `ys workflow run` queues a workflow for the open app to carry out, `ys test run` a smoke test, and `ys pr list` lists every project's open pull requests with what needs attention. `ys workspace delete` removes one when the work is done, keeping the branch. Every command takes `--json`. - **Remote, still under development.** Reach this computer's workspaces and terminals from your phone, and start new ones there, through a Yardsort server you sign in to. It stays off, and connects to nothing, until you turn it on, and a device gets in only if you say yes at this computer. The phone can be told about a task, a review, a failure, a desktop update, a workflow question or approval, an agent that needs you, or one that finished while nobody looked. The notification opens that item. You can answer or approve a workflow on the phone while this computer is online. On the phone a conversation reads as a chat, a column at the phone's width, and Claude Code's permission questions can be answered there, as can a smoke test waiting to be let run. A workspace's pull request shows there too, with its checks and reviews, read-only, and a project folds to put its workspaces away. A bell opens the [Notifications](docs/guide/notifications.md#on-the-phone) list there: what needs you and what finished, on every computer the phone reaches. Installing a desktop update stays on the computer. Whoever runs the server can see what passes through it, and [the phone app](docs/guide/phone.md) is invite only until it reaches the app stores in a few weeks. Expect it to change until the whole plan is finished. See [Remote](docs/guide/remote.md). A Linux computer with no screen, such as a server you reach over SSH, can be one your phone reaches too, with `yardsort-host`, installed with one line or run from a container image that comes with the tools agents use: see [A computer with no screen](docs/guide/headless-host.md). Its agents keep running when the host restarts, and when a reboot ends them, `ys session resume` brings their conversations back. It serves a [dashboard](docs/guide/host-dashboard.md) for setting the server up from a browser, signing it in to a Yardsort server and pairing a phone, installing agents, signing GitHub in, cloning and running commands: on that computer's own `127.0.0.1`, signed in to with a one-time link from a terminal there, reached over an SSH forward or a rustunnel tunnel you turn on. The app can serve the same page, and does not until you turn it on. The desktop app can reach another computer the same way: its projects and workspaces in the sidebar under that computer, opened like your own, with its terminals to watch and, once you have control, to type into. New work starts there from the same composer, by choosing the computer in its title, and an ended conversation can be resumed there. A workspace there shows its changes and files, read-only, and you can commit, push, and open or merge its pull request, which that computer does as itself. Turn on **Sync** for a project and your computers share it: its approved notes reach the agents on each, and each lists the others' workspaces under the project, with **Check out here** to bring one's branch over. A project's files, its path and its terminals never sync. - **Light.** Built with [Tauri](https://tauri.app) and Rust: a few megabytes, not a bundled browser.
The composer: describe a task, pick an agent, model, effort and branch, and tick the triggers the new workspace gets Previous sessions with Resume and Fork
Describe the task, pick the agent, press Enter Come back later: Resume or Fork any conversation
## Usage: tokens, cost estimates and machine resources ![Usage: token totals, estimated API costs, cache savings and workspaces using demo logs](docs/images/usage-tokens.png) Open **Usage** beside **Settings** at the foot of the sidebar, or search for it in the command palette (**⌘K** on macOS, **Ctrl+Shift+K** elsewhere). - **Token usage** reads Claude Code, Codex and Grok's local session logs, including conversations started outside Yardsort. Compare the last **7d**, **30d** or **90d** by day, agent, model and workspace; inspect cache reads, cache writes, output and cache savings. Codex's plan limits show when they were last reported. No activity capture or extra API key is needed. - **Cost** estimates the API price of those tokens in US dollars, rather than your subscription bill. Unknown models, including Grok models, still contribute tokens but no cost. - **Machine resources** shows live CPU and memory for Yardsort, its background terminal host, and each project, workspace and terminal, including the programs an agent starts. Sort by memory or CPU to find the busiest workspace and click its name to return to it. Sampling runs every two seconds while this tab is open and the window is visible. All figures stay on your machine. Token history covers only logs still present there; it does not include other computers. Machine resources covers all agents Yardsort runs, while token totals currently cover Claude Code, Codex and Grok. See the [Usage guide](docs/guide/usage.md) for sources, pricing limits and the option to hide the sidebar button. ## Every pull request in one place ![Pull requests: every project's pull requests in one list, with one open beside it showing its description, checks and reviewers](docs/images/pull-requests.png) **Pull requests**, at the very top of the sidebar, is one list of the pull requests of every project on GitHub — the ones agents opened, the ones you opened, the ones a teammate opened last week — most recently updated first. Each row says who opened it, how the checks stand, how big it is, and which workspace holds its branch. Filter by state, project, author and review status, or search a title or a number. - **Summary** is the pull request as GitHub has it: the description, every check with a link to its run, who was asked to review and what they said, and the conversation, with a box to reply. - **Code** is its diff, read with git into the project's own repository: the files it changes, each with the number of comment threads on it, and the viewer with every thread under the lines it is about. Select lines and **Note on lines…** sends what you want done to the agent that has the pull request's workspace — typed into it if it is running and quiet, resumed if it has ended, or a new workspace started with the note as its first message — and, if you like, posts the same note on GitHub as a comment on those lines. - **Start workspace**, **Merge**, **Close** and **Reopen** act on any pull request from here, each confirmed first and naming whose it is. A fork's pull request gets a workspace too, on a branch Yardsort will not push. ![Pull requests, Code tab: a changed file with a review thread sitting under the line it is about](docs/images/pull-requests-code.png) It needs the [GitHub CLI](https://cli.github.com), logged in; everything here is `gh` with the permissions you already have, and nothing you write reaches `gh` as a command-line argument. See [Pull requests](docs/guide/pull-requests.md). ## Your issues, where the agents are ![Tasks: every project's open issues in one list, with one open beside it showing its description and conversation, and buttons to delegate, close, label and assign it](docs/images/tasks.png) **Tasks**, under Pull requests in the sidebar, is one list of the open GitHub issues of every project, most recently updated first. The number beside it is not how many are open but how many **need an answer**: the last person to speak was not an owner, a member or a collaborator, and a bot's comment counts as nobody's. Filter by project, label, assignee, author and _Needs an answer_, or search a title or a number. - **Delegate** opens the composer with the issue as the agent's first message — its title, description and latest comments, between two lines marked as text other people wrote, followed by what the agent should do if that text asks for more than the work. Nothing starts until you press Start. The workspace is named after the task and remembers it, so the task names its workspaces and the workspace's row shows the task. - **New task**, a reply box, **Close** and **Reopen**, **Labels** and **Assignees** manage issues without leaving the app. Closing and reopening ask first, naming who opened the task. - **From a link…** takes an issue's address — or `owner/repository#12` — and opens it here, selected, cloning its repository first if it is not a project yet. - **`ys task`** does all of it from a terminal — `list --needs-answer`, `show`, `start`, `create`, `comment`, `close`, `reopen`, `edit`, each with `--json` — so an agent in a workspace can tell you what is open and file an issue when you ask. It needs the [GitHub CLI](https://cli.github.com), logged in; everything here is `gh` with the permissions you already have. See [Tasks](docs/guide/tasks.md). ## Hand the work to another agent One agent has worked in a workspace and you want another there — Codex after Claude, or the same agent from a clean start. The files and the diff carry over by themselves. What was asked, tried and found does not. **Hand off…**, in the tab bar, writes the next agent's first message from what Yardsort recorded and opens it in the composer, where you read it, edit it, pick the agent and press Enter. ![Hand off: the composer holding the next agent's first message](docs/images/handoff.png) It is written from the record, and no model writes it. Yardsort never keeps a conversation; in a project where you let the agents read each other's, a _What was said_ part adds your messages and each turn's final reply, read from the agents' own transcripts when you press **Hand off…**. An excerpt of a real one, from a project that does not share them: ```markdown ## What this workspace was asked > Add an --imperial option that shows °F and mph ## Where the work stands - Branch `ys/add-imperial-option-shows`, started from `main`: 0 commits on it since. - Uncommitted: 4 files - `src/render.js` (modified, +10 −5) — last written while claude ran a command; not reported - `tests/render.test.js` (modified, +8 −0) — last written while claude ran a command; not reported … ## What the agents did here - **claude**, started 2026-09-27 11:39 UTC, **still running**. - 1 turn. - Tools: Bash ×2. ## What is not here - The conversations themselves: what the agents said, reasoned, tried and rejected. Yardsort records metadata only. If that matters, ask the user before assuming. ``` It says where it is blind, and tells the next agent to ask you. With [Assist](#assist-judgment-from-jev-if-you-want-it) on, the changed files come in the order Assist would look at them. The handoff is not the task: the new conversation keeps your original words as what the workspace was asked. From a terminal, `ys workspace handoff ` prints the same message. See [Handing work to another agent](docs/guide/terminals-and-sessions.md#handing-work-to-another-agent). A handoff shares the workspace. To build the next feature on this one in a worktree of its own, **Fork into new workspace…** in the workspace menu makes a new branch from its branch and sends the same record after your message, which is the new workspace's task. Uncommitted files stay where they were. From a terminal, `ys workspace fork ""` does the same. See [Fork into new workspace…](docs/guide/workspaces.md#fork-into-new-workspace). ## Shared conversations: agents that know what the others said A handoff is one message, at one moment. An agent working beside another can also just ask. `ys workspace context` prints what was said in the workspace's other conversations: every message you typed and each agent's reply at the end of each turn, newest first, within about 8,000 tokens. What does not fit is listed by turn, and `--turn` shows any one whole. It looks like this, shortened, with made-up words: ```markdown # What was said in this workspace ## claude (opus) · conversation 3f2a1b9c · 12 turns · started 2026-11-02 09:14 UTC · last turn 2026-11-02 11:40 UTC · running ### Turn 12 · 2026-11-02 11:40 UTC User: > leave the retry out for now, it hides the real failure Agent: > Removed it. The login test now fails on the expired fixture, which is the actual bug. ``` Yardsort reads these from the agents' own transcripts when the command runs, for Claude Code, Codex, Grok, Cursor, OpenCode, OMP and pi alike. Tool calls, their output and the agents' reasoning are left out, and no copy is kept. An agent started in a workspace where another has said something is told, in a short note, which conversations there are and how to read them. Most agents take that as background context, so one started from the tab bar knows without a first message and starts no turn. Its tab says so, with **Show** to see the note; **Alt-click** starts an agent without it. This is on unless you untick **Share conversations between this project's agents** in a project's Memory view. What an agent reads goes to that agent's provider: Claude's conversation, read by Codex, is sent to OpenAI as part of Codex's work. See [what agents can read of each other](docs/guide/terminals-and-sessions.md#what-agents-can-read-of-each-other). ## Workflows: named agent work, in steps A workflow is a named, reusable piece of agent work that runs in steps — have a second agent review this workspace's pull request, then tell me and the agent that wrote it. It is a short YAML file in your profile: the inputs to ask for, and steps that start an agent, wait for it to settle, type to it once it is quiet, wait for a review on the pull request, and notify you. A step names the steps it needs, so the ones that need nothing of each other run side by side. Yardsort checks every name and every `{{ variable }}` before it runs anything, and names the line and column of each mistake. A `run_test` step marked `gate: true` stops the run when the smoke test fails, skips the steps still going, cancels a smoke test they were waiting on, and says why. A step can also hand a named document, such as a spec or a test report, to the step after it. The next agent receives that text, and the run keeps it so you can read what was passed on. ![Workflows: a finished Software factory run, with its steps, the result it reported and the pull request it opened](docs/images/workflows.png) **Workflows** in the sidebar lists the built-in ones and yours, each marked built in or custom, and deletes yours. Open one to see its steps as a chart, its file in an editor with every problem marked where it is, and its runs. Rather not write the file? Say what it should do and press **Write it**: the agent you already have, or your Anthropic key, writes it — checked like any other, and never saved until you say so. The built-in **Request code review** is in every workspace's menu: a second agent reviews the pull request in the same worktree and posts on GitHub, then you are told, and the agent that wrote it is told to address the review. From a terminal, with Yardsort open: ```sh ys workflow run code-review --workspace fix-login --input reviewer=codex ``` The built-in **Software factory** takes a task from a brief you clarify, through a plan you approve, implementation, a smoke test it writes itself and a second agent's code review, and stops when you say it is ready to release. It does not merge or deploy. The app carries the run out in the background, with the agents it starts as ordinary tabs, and `ys workflow runs` follows it step by step. See [Workflows](docs/guide/workflows.md). ## Smoke tests: the ten-minute check, repeatable A smoke test is a short, structured list of steps that checks a piece of software from the outside — start the server, wait for it, hit an endpoint, open a page, click a button, look for a word. Today an agent writes those steps as prose and you do them by hand, every time. Yardsort makes them a file the agent writes, the app runs, and you watch: typed steps with expectations, browser actions over the DevTools protocol against a Chromium already on your machine, and variables for ports and secrets. The file lives in your repository, at `.yardsort/tests/.yaml`, so the test travels with the branch. Because it comes from a repository and says what to run, **a file never runs until you have seen it**: the first time Yardsort meets a file — new, or changed — it shows the steps and asks you to approve them; from then on that exact file runs without asking. **Tests**, in the sidebar, lists every project's tests with the verdict of each one's last run, and a **Runs** tab of every run; filter by project, workspace, verdict or what the machine lacks. A run opens as a tab beside the agent whose work it checks, each step with its status, the one running with its live output, a failed one with what it expected, what it got, and the screenshot it took. An agent writes a test itself, or press **Describe it** and a model writes one for you to check and save. **Send result to agent** types the verdict into the workspace's agent once it is quiet, and a [workflow](docs/guide/workflows.md) can run a test too: the built-in **Smoke test, then tell the agent** does both. ![Tests: every project's smoke tests in one list, each with the verdict of its last run and the workspace it ran in, a Runs tab, filters, and Describe it](docs/images/tests.png) A test or a workflow can also run on a [schedule](docs/guide/schedules.md): once at a time you pick, or on a routine such as every weekday at nine, in a workspace you already have, while Yardsort is open. A workflow's schedule can instead make a new workspace for each run. Yardsort never removes those: the schedule keeps up to a number you set, then waits for you to archive or delete one. ![Schedules: every project's schedules in one list, each with what it runs, when, and how its last time went, and one open that makes a new workspace for each run, with how many it keeps and its history](docs/images/schedules.png) From a terminal: ```sh ys test run login --workspace fix-login # the result from `ys test wait` ``` See [Smoke tests](docs/guide/smoke-tests.md). ## Triggers: when something happens A trigger starts a workflow or a smoke test in a workspace when something happens there, instead of when you press **Run**: the agent runs `ys workspace done`, finishes a turn or exits; a smoke test or a workflow run ends; the workspace's pull request opens, gets a review or a comment from someone else, or its checks fail; or an agent, a test or a script raises an event you named with `ys event emit`. What it starts is an ordinary run, marked _triggered_. Five come ready made, each an event and a built-in workflow: **Address reviews**, **Fix failing checks**, **Review the pull request when it opens**, and **Review** or **Smoke test when the work is done**. The composer offers them as boxes to tick for each new workspace, and an agent whose workspace listens for `ys workspace done` is told to run it in its first message. ![Triggers: every trigger with its event, what it runs and how its last run went, and one open with its history](docs/images/triggers.png) **Triggers**, in the sidebar, lists every project's triggers, and the dialog says in a sentence what one will do before you save it. Agents answer reviews as your account, so only posts from other accounts count unless you say so. A trigger stops after three runs for one pull request, agent or workspace, unless you give it more, until you press **Reset**; it starts at most ten an hour; and a chain of runs that set each other off stops three deep. Triggers fire while Yardsort is open; what happened while it was closed is found when it opens. ```sh ys trigger add --preset address-reviews --workspace fix-login ys event emit migration-written --note "0042 adds users.last_seen" ``` See [Triggers](docs/guide/triggers.md). ## On your phone ![The phone app: a computer's workspaces with their pull requests, one pull request's checks, a conversation as a chat, and an agent's permission question](docs/images/phone.png) Yardsort has a phone app that reaches the agents on your computer. See what each workspace is doing and how its pull request stands, read a conversation as a chat at the phone's width, answer Claude Code when it asks to run a command, let a waiting smoke test run, and start new work, away from your desk. A bell lists what needs you and what finished on every computer, and the phone is told when an agent finishes while nobody is looking. The agents run on the computer, so they keep going whatever happens to the connection. The phone gets in only through a server you sign in to, and only after you say yes at the computer. **The app is invite only for now, and will be in the app stores in a few weeks.** [Write to us](mailto:hello@yardsort.sh) if you would like to try it before then. It is part of [Remote](docs/guide/remote.md), which is still under development. See [The phone app](docs/guide/phone.md). ## Supported agents Yardsort starts any coding agent that runs in a terminal. These work out of the box: | Agent | Command | Resume | Fork | Writes commit messages | | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------------- | :------------------ | :----------- | :--------------------- | |  [Claude Code](https://claude.com/claude-code) | `claude` | Any conversation | Yes | Yes | |  [Codex](https://github.com/openai/codex) | `codex` | Latest in workspace | Latest | Yes | |  Grok | `grok` | Any conversation | Yes | Yes | |  [OpenCode](https://opencode.ai) | `opencode` | Latest in workspace | Latest | Yes | |  [OMP](https://omp.sh/) | `omp` | Latest in workspace | — | Yes | |  [Cursor](https://cursor.com/cli) | `cursor-agent` | Latest in workspace | — | — | |  [Pi](https://pi.dev/) | `pi` | Any conversation | Yes | Yes | | Any other terminal agent | yours | Configurable | Configurable | Configurable | Anything else is [a few lines in `settings.toml`](docs/guide/settings.md#adding-your-own-harness) — a command and some argument templates, no plugin and no release to wait for: ```toml [[harness]] id = "aider" label = "Aider" command = "aider" prompt_transport = "stdin" ``` Each agent uses its own login; Yardsort only starts it. Install and sign in to an agent before launching a workspace with it. ## Install Download the latest build from the [**Releases page**](https://github.com/joaoh82/yardsort/releases/latest): | System | File | | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | | **Linux** | `.AppImage` (portable), `.deb`, or `.rpm` (an AUR package, `yardsort-bin`, is on its way) | | **macOS** | `.dmg` — universal (Apple Silicon and Intel), signed and notarized — or `brew install --cask joaoh82/yardsort/yardsort` | | **Windows** | `-setup.exe` or `.msi` — not code-signed yet: choose _More info → Run anyway_. (`winget install joaoh82.Yardsort` is awaiting Microsoft's review.) | On Linux, the quick start shows how to [add the AppImage to your app menu](docs/quick-start.md#linux-add-the-appimage-to-your-app-menu). You also need **git** and at least one agent CLI that already works in your terminal (for example [Claude Code](https://claude.com/claude-code)). Yardsort does not bundle agents and never sees their credentials. ## Quick start 1. Open Yardsort and press **+** next to _Projects_ → **Open a folder** → choose a git repository, or **Clone a repository** to pick one of yours on GitHub from a list — or paste a URL from any git host — and download it into a new local folder. Or paste an issue's link into **Start from a link…** and let Yardsort clone its repository on the way. 2. Press **+** on the project (or `Ctrl+Shift+N` / `⌘N`), type what you want done, press **Enter**. 3. Watch the agent in the middle, and its changes on the right. Start more workspaces in parallel. Open **Usage** in the sidebar to compare their tokens and inspect live CPU and memory. 4. The result is an ordinary git branch — review it, push it, open a PR — or have a second agent review it: **Request code review…** in the workspace's menu. The [quick start guide](docs/quick-start.md) walks through it with pictures, and the [documentation](docs/README.md) covers every part of the app. Both are also on the website, at [yardsort.sh/docs](https://yardsort.sh/docs/). Moving local worktrees from Conductor? See [Migrate from Conductor](docs/guide/migrate-from-conductor.md). ## Assist: judgment from Jev, if you want it Yardsort never parses what an agent prints — status, readiness and notifications come from terminal activity alone, and that does not change. A diff, though, is text a model can be asked about. **Assist** is the optional feature that does so, using [Jev](https://docs.typesafe.ai), TypeSafe's judgment model. Jev never generates text. It answers a _typed_ question about a piece of state — a yes/no probability, a choice among named options, or a position on ordered levels — and Yardsort decides what the number means. That keeps the interesting part in code: the questions are narrow (one property each), the thresholds live in your settings, and the model is pinned (`jev-1.13.0`) so a new version cannot quietly move under them. ![Settings → Assist, with the API key and the switches for what Assist may do](docs/images/assist.png) **On the changes list**, shortly after an agent stops writing, each changed file is checked against what the workspace was asked to do, and flagged files get a badge: | Badge | What it means | | --------------- | ----------------------------------------------------------------------------------------------------- | | **off-task** | The change looks unrelated to what this workspace was asked to do. | | **secret** | The change looks like it adds a literal key, token or password. | | **tests** | The change looks like it deletes, skips or weakens a test. | | **checks** | The change looks like it switches a lint, type check or CI step off. | | **credentials** | The file's _name_ says it holds credentials — decided locally, contents never sent. | | **unaccounted** | A substantive change no agent accounted for, while agents were reporting. Only with the switch above. | **Who wrote each file**, if you switch it on too: with each diff, Assist is told in one sentence what the Changes list already says — reported written by an agent, written while one ran a command, or by nobody the record knows of — never a tool, a time or a command. A substantive change no agent accounted for then gets one more badge, **unaccounted**, and every badge's tooltip ends with the sentence Assist was told. **In the composer**, while you type the first message, Assist can offer a harness and an effort level, built on **your** own "Good at" descriptions of your harnesses rather than on any opinion of ours. Press **Use** to apply it; ignore it and nothing happens. **You decide how sure is sure enough.** Three thresholds — flag a risky change at 70%, call a file off-task at 60%, offer a suggestion at 50% — are settings with **Restore defaults**. Yardsort caches Jev's answers rather than the badges, so moving a threshold re-reads what has already been said: no new requests, no waiting. **What it costs you:** Assist is off until you enter your own TypeSafe API key and tick a feature. The key goes to your system credential store (Keychain, Credential Manager, Secret Service), never into `settings.toml`, and requests are billed to your account. What leaves the machine is the diff and path of a changed file plus the task — and, only with that switch, the one sentence on who wrote it — or the message you are typing plus your "Good at" texts. Nothing else, and never a terminal. Files whose names say they hold credentials are badged without their contents being read. Nothing here is load-bearing: with no key, switched off, offline or rate-limited, Yardsort behaves exactly as it does otherwise, minus a few badges. The [Assist guide](docs/guide/assist.md) covers all of it, including what to do when TypeSafe says no. ## Documentation | | | | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- | | [Quick start](docs/quick-start.md) | Download to first agent in five minutes | | [Projects](docs/guide/projects.md) · [Workspaces](docs/guide/workspaces.md) | Repositories, branches, worktrees, archiving | | [Migrate from Conductor](docs/guide/migrate-from-conductor.md) | Import existing local worktrees and reconfigure scripts by hand | | [Terminals & sessions](docs/guide/terminals-and-sessions.md) | Tabs, status dots, notifications, resume and fork, handing off, shared conversations | | [Notifications](docs/guide/notifications.md) | One list of what needs you and what finished unseen, over every project | | [Changes & files](docs/guide/changes-and-files.md) | Reviewing what an agent did | | [Activity](docs/guide/activity.md) | What ran, what each agent reported, who wrote which file | | [Memory](docs/guide/memory.md) | Lessons for a project's agents, approved by you | | [Outcomes](docs/guide/outcomes.md) | What became of each attempt, and each agent's history | | [Pull requests](docs/guide/pull-requests.md) | Every project's pull requests: filter, start a workspace, merge | | [Tasks](docs/guide/tasks.md) | Every project's GitHub issues: which need an answer, hand one to an agent | | [Workflows](docs/guide/workflows.md) | Named agent work in YAML: the built-in code review, your own | | [Smoke tests](docs/guide/smoke-tests.md) | A file an agent writes and Yardsort runs: steps, browser, approval, the Tests view | | [Schedules](docs/guide/schedules.md) | A workflow or a smoke test at a set time, or on a routine | | [Triggers](docs/guide/triggers.md) | A workflow or a smoke test when something happens: done, a review, failing checks | | [Remote](docs/guide/remote.md) | Your phone and your other computers, through a server. Still under development | | [The phone app](docs/guide/phone.md) | What it does and what it needs. Invite only for now, in the app stores in a few weeks | | [A computer with no screen](docs/guide/headless-host.md) | `yardsort-host`: a Linux server your phone reaches. Still under development | | [The host dashboard](docs/guide/host-dashboard.md) | A web page for setting a host up from a browser: Remote, agents, Git, setup commands | | [Usage](docs/guide/usage.md) | Tokens spent and their cost; CPU and memory per agent | | [Updates](docs/guide/updates.md) | How new versions reach you | | [Settings & harnesses](docs/guide/settings.md) | Configure agents, add your own | | [Assist](docs/guide/assist.md) | Optional Jev checks on changes and composer hints | | [The `ys` command line](docs/guide/cli.md) | Installing it; workspaces, agents, `attach`, `logs`, handoffs | | [Keyboard shortcuts](docs/guide/shortcuts.md) · [Troubleshooting](docs/guide/troubleshooting.md) | | | [Design docs](docs/design/README.md) | Architecture, harness model, roadmap, open questions | ## Build from source You need [Rust](https://rustup.rs) (stable), [Bun](https://bun.sh), git, [`just`](https://just.systems), and Tauri's [system dependencies](https://tauri.app/start/prerequisites/) for your OS. ```sh git clone https://github.com/joaoh82/yardsort && cd yardsort just setup # install dependencies just dev # run with hot reload just check # formatting, lints, types, all tests just build # installers for this OS, in target/release/bundle/ ``` `just` alone lists every recipe. See [CONTRIBUTING.md](CONTRIBUTING.md) for how the code is laid out and how to send a change. ## Status Early, and moving fast. The core loop — projects, parallel workspaces, configurable agents, live review, resumable sessions — works on all three platforms and is covered by CI on each. Expect rough edges, and please [report them](https://github.com/joaoh82/yardsort/issues/new/choose). For complete examples, visit the [tutorials](https://www.yardsort.sh/tutorials/). The [blog](https://www.yardsort.sh/blog/) covers product decisions and tool comparisons. The [changelog](CHANGELOG.md) says what changed, and the [roadmap](docs/design/05-roadmap.md) what is next. ## Contributing Issues, ideas and pull requests are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) and the [Code of Conduct](CODE_OF_CONDUCT.md). To report a vulnerability, see [SECURITY.md](SECURITY.md). ## Get in touch Bugs and feature requests belong in the [issue tracker](https://github.com/joaoh82/yardsort/issues/new/choose), where everyone can find them. For anything else — a question, help getting started, or just to say what you are building with it — write to **[hello@yardsort.sh](mailto:hello@yardsort.sh)**. ## Team [![João on X](https://img.shields.io/badge/Jo%C3%A3o-@codepolyglot-555?logo=x)](https://x.com/codepolyglot) ## License [GPL-3.0](LICENSE). Yardsort is free software: you may use, study, share and change it, and versions you distribute must stay free under the same terms. The remote server, `crates/server`, is [AGPL-3.0](crates/server/LICENSE): the same terms, and whoever runs a changed copy for others over a network must offer them its source too. The phone app, `apps/mobile`, and its TypeScript protocol client, `packages/remote-client`, are [MPL-2.0](apps/mobile/LICENSE), so that the app can be published through app stores. Why, and what stays out of this repository: [docs/design/30](docs/design/30-open-source-and-managed.md). The website's fonts are under the SIL Open Font License: [website/src/app/fonts](website/src/app/fonts/README.md). Yardsort was called **Switchyard** until v0.2; if you used that, your projects and settings come along automatically the first time you start Yardsort. Yardsort is an independent project, not affiliated with Anthropic, OpenAI, xAI or any other maker of the agents it can launch. Product names belong to their owners.