Skip to content
Docs0.9GitHubInstall

Running itPeople

People

People: Tom and Rui each have their own Vendetta on this computer, with a pairing code, the skills shared with them, and a button to remove themPeople: Tom and Rui each have their own Vendetta on this computer, with a pairing code, the skills shared with them, and a button to remove them

A person is a Vendetta of their own on this computer: their own worker, Master, schedules, app/web endpoint, and paired devices, running under your account. Their agents run only in their container projects, in your rootless Podman, never on the host. By default they have what you have: your Claude, git, and shared services, through you, never a copy of your credentials. They own their Vendetta; it never sees your agents, and yours never see theirs.

vendetta instance add ana          # their folder, workers, tailnet port, Master, pairing code
vendetta instance pair ana         # a new pairing code for their app or browser
vendetta instance list             # each person's port, worker, and address
vendetta instance update           # after you deploy: config written again, workers restarted
vendetta instance update ana --services own # none of your services (--services proxy: yours)
vendetta instance update ana --master off   # no Master for them (--master on: theirs again)
vendetta instance remove ana       # confirm, then their workers, machines, and folder go
vendetta instance rename ana "Ana" # what people see them called

Run them as yourself; nothing needs sudo. --dry-run on add, update, and remove prints every step and runs nothing. Every step checks before it acts, so rerunning a command that failed finishes it; list shows an unfinished one as incomplete: STEP.

  • Rootless Podman. People’s machines always run in it, on an image instance add gets for them (people/image.json) and instance update gets again after an install, as machine image build does, whatever runtime your own machines use. Without a Master ([people] master = false), the image is got by the first update after they have a machine.
  • loginctl enable-linger, so your user manager, and their Vendetta with it, keeps running when you log out.
  • For their addresses on your tailnet, the Tailscale plugin, with sudo tailscale set --operator=$USER once, so it runs tailscale serve as you. Without it, serve each person’s port yourself; add says which.
  • ~/.local/state/vendetta/people/ana/ (0700): their state, their config, their projects (home/projects), and the Claude proxy folders of their machines.
  • Their workers: vendetta-person-schedule@ana and vendetta-person-notify@ana, your user units, which run vendetta person ana … in their folder. A person runs your installed Vendetta.
  • A config you own (people/ana/config/vendetta/config.toml): the next free app port from 8744 and a public_url on your tailnet host (this machine’s, as the Tailscale plugin reports it, else your own app address’s, or --tailnet-host), their machines’ names (vendetta.ana.PROJECT), limits, image, and your [machines] instructions. update writes these tables again; any other table you add (their [plugins.ntfy], say) stays.
  • Their Master: an agent in their master container project, alone there. Their apps show it as the Master’s row only, never as a project, and it is not shared.
  • A pairing code, and with the Tailscale plugin their tailnet port and their own name (vendetta-HOST-ana.TAILNET) beside it, which becomes their address once a tailnet admin defines its Service and approves this machine as its host; list shows what it waits for.

Their machines’ limits are yours to set:

[people]
memory = "2g"   # each machine
cpus = 2.0      # each machine
pids = 1024     # each machine
machines = 5    # per person
master = true   # make each person's Master

A consumer Claude subscription is for one person: serving another person’s Claude from yours is account sharing under Anthropic’s terms. It is your call; --claude-login own gives them their own account instead.

Their phone needs tailnet access to this machine: invite them or share the machine. Messaging bots for them are not set up; add their own to their config.

Your own agents run as you, so they can read people’s folders. Their agents run in containers, which see only their own clone and their own sockets.

A person has what you have configured, through you: each capability below is on unless you turn it off for them, and your credentials never leave your account.

Capability Flag on add and update Through
Claude --claude-login proxy|own your Claude proxy, for their machines
Git --git proxy|own your git login for your git hosts, for their machines
Services --services proxy|own every service your plugins share with people, such as transcription and narration, through your worker
Master --master on|off their own Master, an agent in their master container project

proxy is the default. With --claude-login own, they log in inside each machine (vendetta machine login NAME, or its terminal in the app). update writes a change to their folder and restarts their workers. list shows each person’s (“yours: claude, git, services; their own: nothing”). The apps’ People screen has a switch per capability for each person, which runs the same update.

Without a Master (--master off), they have no Master row, no To Master, and their Telegram or Discord General chat and Master schedules say there is none; they still start agents in their projects. An existing Master’s machine is stopped and kept for it ([master] kept in their config): it is yours to manage, it does not count against their machines, their apps do not list it, nothing starts in it, and the old Master’s chat shows only in their history. --master on starts a new Master there, as add does. [people] master = false gives no one a Master, whatever each person’s switch says.

Nothing of your skills and MCP servers is shared until you pick it, one by one, for a person, for everyone (people added later too), or for your own container projects:

vendetta instance shared [ana]                    # your skills and servers; ana's picks
vendetta instance pick ana --skill writing-plans  # --mcp NAME for a server; --off to stop
vendetta instance pick --everyone --skill humanizer
vendetta instance pick --machines --mcp gateway   # your own container projects
vendetta instance pick ana --mcp gateway --reload # then reload her sessions, each once idle
vendetta instance reload ana

A shared MCP server runs on your side, as you: they can use it as you can. Their machines’ Claude loads what you pick from a plugin your proxy keeps in each machine’s folder. Their own skills and servers, in each of their machines, stay theirs, and one of the same name wins over yours there. See plugins.

They connect GitHub (and providers like it) themselves, in their Settings → Connections, with your [plugins.github] client_id, which add and update write into their config while your GitHub plugin runs. Its token stays in their folder and reaches only their machines; you see only whether it is connected and as whom (People, instance list: “connected: GitHub: octocat”).

With [plugins.claude-proxy.git] on your side (plugins), their machines’ git clones, fetches, and pushes your git hosts’ repos with your login, which never leaves your proxy. They can read every repo your login can and, unless a host has push = false, push to it. With --git own, their machines get no git.sock.

remove lists what goes and asks you to type the name (--confirm NAME without a terminal): their tailnet port, each machine’s container and volumes, their workers, and their folder with their conversations, chats, paired devices, and clones. --keep-state keeps the folder as people/.removed/NAME-DATE, with each machine’s volumes exported beside it (NAME-DATE.volumes/*.tar).

Only people add made are touched; the record is instances.json in your state directory.

Your app and web devices can do all of this too (People, in Settings): add a person with their display name, show a new pairing code (made by their own Vendetta), update one or all, rename, and remove. Your worker runs the same commands and the app shows each step; a failed one shows its output and Retry runs it again from its checks. remove shows its plan first, and goes only while nothing in it changed.

A paired device of yours can add and remove people and their containers. Revoke a lost device at once: vendetta app devices, then vendetta app revoke ID.

People see each other’s names only. You also see each person’s project names and machine states, and can start, stop, fetch, recreate, and remove their container projects, and make new ones in their folder: their Vendetta does it. You never see their chats unless they share one.