Vineyard

Every Claude Code agent, on every machine you own, in one VS Code window.

Vineyard shows every Claude Code session on every machine you own in one tree: what each agent is doing right now, which ones are waiting on you, and what they are working on. Open any agent's conversation, answer its permission prompt or question from wherever you happen to be sitting, start new agents on other machines, and stop the ones that have wandered off. A tiny daemon on each machine makes it work; the daemons talk only to each other, and only while you are looking.

Run a fleet, not a window

• One tree for everything. Machines › workspaces › agents › subagents › background tasks, each with its live state: working, thinking, running a tool, asking you a question, waiting for permission, idle. A session whose own turn has ended but whose subagents are still running shows as working ("2 subagents working"), not idle. Model, effort, context size, branch, uptime and the last prompt are a hover away.
• Know who needs you. A machine row rolls its agents up ("1 needs you · 2 working"), the status bar counts the whole fleet, and an optional notification fires when an agent asks a question, wants a permission, or finishes while you were elsewhere. Sort any tier attention-first and the agents that need you rise to the top and stay put.
• Subagents, nested to any depth. Every Agent-tool invocation Claude Code spawns sits under its parent with its own state, model and running time, and opens its own read-only transcript. Shell commands left running in the background appear beside them.
• Sleeping machines are woken with Wake-on-LAN when you look at them, a watched Mac is kept awake so its agents do not stall, and a machine nobody can reach shows its last-known state.
• Usage limits across the fleet. The fullest account limit shows on the machine row and in the status bar, so you see a session window filling up before an agent hits it.

Answer from wherever you are

• Permission prompts, questions, plan reviews and MCP elicitations arrive as cards in the chat and are answered there, with the same choices the Claude Code pane offers: allow once or remember the rule, pick an option or type your own, approve a plan or send it back with feedback.
• Any running agent takes messages, including ones started in the Claude Code pane or a terminal. Attach images and files; they travel to the agent's machine with the prompt.
• Take over a session that was started elsewhere when it needs an answer only Vineyard can give. The daemon on that machine ends the process and resumes the same session as its own child; a pending question survives the switch and is asked again in the chat.

Start, resume, hand over, stop

• New Agent Here… in any workspace on any machine. It starts with the model, effort and permission mode you last used in that workspace, and the pickers in the chat change the running session in place. Where nothing was picked yet, or after you change the default in Claude Code's settings, it follows those settings.
• Resume a Past Session… from the transcripts on any machine, newest first, with title, first and last prompt, model and branch. Or resume it in a terminal on that machine.
• Pause a turn mid-flight, Stop a session cleanly, or Terminate one you did not start. The transcript stays on disk either way.
• Sign In to Claude on Machine… when a remote machine's login expires: the daemon runs the sign-in there, Vineyard opens the URL in your browser and passes the code back.
• Update Claude Code on Machine runs claude update on that machine and shows what it said.
• Switch Claude Account on Machine… (experimental, behind vineyard.experimental.claudeAccounts, or Settings › Experimental in the web app): keep several Claude subscription accounts signed in on a machine and swap between them, as if you had signed in again as the other one. Sessions, transcripts and memory stay put. Saved sign-ins stay on that machine, in its keychain on macOS.
• Rename a session by clicking its title; Claude Code shows the new name too.
• Remove Transcripts on a finished session, or Remove Project on a workspace, clears out what Claude Code left behind on that machine — transcripts, subagent transcripts, saved tool results and the registry entry that keeps an exited session listed — so it stops showing up. Your code is not touched, and neither is the project's memory/. A session still running is refused.

A chat that keeps up with Claude Code

• The same toolbar as the pane: attach, a filterable / menu with every slash command the session offers, a context-window donut (click to compact), a prompt-cache clock counting down to expiry, and pills for model, reasoning effort and permission mode.
• An agent map of every subagent and background command with state, running time and tokens. Each row opens its transcript; each running row has a Stop button.
• A transcript built for long sessions: the current prompt stays pinned while you scroll, thinking is collapsed, tool calls fold to one line with IN/OUT blocks for shell commands, and an activity ticker shows what the agent is doing while it is busy. It opens on the last 400 lines and loads earlier ones as you scroll to the top.
• Account & usage in the / menu, with a bar per limit window, and a dismissable banner from 80 % that behaves like the pane's.

On your phone

Turn on vineyard.webApp.enabled and every machine's daemon also serves Vineyard to its local network, sized for a phone. The tree becomes a stack of screens you tap through (machines, workspaces, agents, then subagents and background tasks), and the chat is the same one VS Code shows, with its cards, / menu and pickers sized for a thumb. You can start, resume, take over, stop and rename agents, answer their questions and permission prompts, attach photos, sign a machine in to Claude and wake a sleeping one. vineyard.webApp.machines limits it to some machines, and vineyard.webApp.port (7735) sets the port.

It is young but in daily use from an iPhone's home screen, and the mobile layout is still being reworked as that turns things up, so expect it to change from release to release.

A phone sees nothing until it is paired. Run Vineyard: Pair a Phone with the Web App, open the link it gives you on the phone (or type the code), and the phone gets its own credential. A phone pairs with one machine and sees the whole fleet through it; the app marks that machine Serving this app. Every visit renews the credential, and a phone unseen for 30 days is signed out. Web App Devices… in VS Code, or Settings on a paired phone, lists paired devices and signs them out. On an iPhone, open the link in Safari and choose Share › Add to Home Screen for a full-screen app with an edge swipe to go back.

Securing the route is up to you. A paired phone can read every transcript and drive every agent, and the app is plain HTTP: anyone on the same network can read the traffic and copy a paired phone's credential. Turning the setting on asks you to confirm that on each computer. Use it on networks you trust, or reach it over Tailscale, a VPN or a TLS reverse proxy (list the proxy's name in webAppHosts in ~/.vineyard/config.json), and firewall the port elsewhere. Pushing daemon updates, adding machines, creating invite codes and rotating the fleet key stay with VS Code and the CLI. The app keeps the fleet as quiet as VS Code does: it attaches to its daemon only while a paired page is open and in front.

Tools for your agents

The sessions Vineyard starts can be given tools that see and use the fleet, each behind a vineyard.agentTools.* setting, all off by default:

• listMachines: which machines there are, their OS and the common programs each one has, and which machines have a program you name (find_machines ["docker", "gh"]).
• listWorkspaces and listSessions: the project folders, and what every live session is doing.
• fetchTranscripts: download any session's transcript to ~/.vineyard/transcripts. The agent gets back the path and a condensed Markdown copy, not the whole transcript in its context.
• driveAgents: start an agent on another machine or message a running one, and get its reply back in your agent's own conversation when that turn ends. Messages are marked as coming from an agent, chains stop at 3 hops, a machine accepts them only while its own setting is on, and permission prompts on the far side are still yours to answer.

The tools come from an MCP server built into the daemon. Claude Code loads one only when the conversation needs it, so tools that go unused cost a few lines of context.

Quiet, private, yours

• No hub, no cloud, no account. One static Go binary per machine, talking to its peers over mutually authenticated TLS. Each machine has its own key and a certificate signed by the machine that brought it in; no key anywhere can mint identities.
• Silent unless watched. With no VS Code looking, a daemon holds no connections and does not even read the Claude directory. Snapshots are pushed only on change, and only to a viewer. The one exception is a machine nobody can connect to (a laptop on hotel Wi-Fi), which keeps a single idle uplink to another member so it can still be reached; "uplink": "off" turns that off.
• A mesh that heals itself. Every member learns the whole fleet from whichever member it reaches, keeps the addresses that worked most recently, relays through another member when there is no direct path, and switches back to direct as soon as one appears. The relay only sees ciphertext.
• Nothing leaves your machines. Vineyard reads Claude Code's own on-disk state and shows what Claude Code already reports. The one outside request is an optional once-a-day check for extension updates, and only for installs that did not come from the Marketplace.
• Join without SSH with a single-use invite code, or bootstrap over SSH where you have it. Removing a machine revokes its key everywhere, which is all a lost laptop needs.
• A fleet that updates itself. Upgrade the extension on one machine and it brings every daemon up to the same version over the mesh. Daemons install only builds signed with the project's release keys, so a machine in the fleet cannot push code to the others. See SECURITY.md.
• macOS, Linux and Windows, arm64 and amd64, daemons bundled for every platform. The author's own fleet mixes all three, including a Windows desktop that joined with an invite code.

Beyond the Claude Code pane

Vineyard is not a replacement for the Claude Code pane; it is the view above it. These are the things it does that the pane has no equivalent for.

Getting started

The setup guide walks through creating a fleet and adding machines step by step, with screenshots, network requirements and troubleshooting. In short:

1. Install Vineyard from the Extensions view and open its icon in the Activity Bar.
2. Set Up This Machine. This writes ~/.vineyard/config.json, gives the machine its own key and certificate, and installs a login service. Your local agents appear within a second.
3. On the next machine, install the extension and choose Join Fleet with Invite Code, pasting a code from Vineyard: Create Invite Code on a machine that is already in. The joiner needs only TCP reachability to the inviter on the daemon port (7734 by default). Add Machine does the same over SSH if you prefer.
4. Repeat for each machine, from any machine. Every daemon learns the others, so whichever machine you open VS Code on becomes the one that watches.

Each machine needs Claude Code installed. Only Claude Code is detected today; the daemon, model and tree are provider-agnostic so others can be added.

Claude Code feature coverage

Everything the Claude Code pane can do, and whether Vineyard can do it, in two flavours. Observed sessions were started in the pane or a terminal: Vineyard watches their transcript and can message them, but Claude Code accepts permission answers, question answers and control changes only from the process that owns a session. Managed sessions were started, resumed or taken over from Vineyard, and run as children of that machine's daemon, so the whole control channel is available. Whenever a row says Not possible for observed sessions, Take Over Session is the way through.

Supported (30)

Works in Vineyard today, for managed sessions at least.

Partial (18)

Present in a reduced form.

Not yet (38)

Reachable, mostly over the control channel Vineyard already uses, but not built.

Not possible (11)

Blocked by Claude Code itself or by the agent living on another machine.

Known gaps

• On Windows, ~/.vineyard is not yet locked down with ACLs (see SECURITY.md).
• Installing on a Mac over SSH needs the target user to have a GUI login for launchctl bootstrap; the installer falls back to launchctl load -w.
• Relays are one hop: a machine that no member you reach can reach either shows last-known state only.

Learn more

• Setting up a fleet: the first machine, invite codes, adding machines over SSH, networks and firewalls, removing machines, troubleshooting.
• How it works: the daemon, the mesh, how agent state is derived, the wire protocol, building from source and cutting a release.
• Releases carry a .vsix with every platform's daemon bundled, plus standalone vineyardd binaries and checksums.
• Issues for bugs and requests. Report a problem in the chat's / menu opens one with the versions filled in.