Skip to content
Docs0.9GitHubInstall

Running itSecurity

Security

What Vendetta runs and where, every connection it makes and what turns each on, how pairing and approvals work, and what it keeps.

What Vendetta does on your computer and what leaves it, for whoever decides whether to run it and how to expose it. The short version: everything runs as you on your own computer, nothing listens on the network or connects out until you turn it on, and approvals are yours alone.

What Runs as Where
The worker and the scheduler You Your computer, one of each per user
Plugins (messaging, hosts, HUD, speech, and the rest) You, with your permissions and no sandbox Your computer, started and stopped by the worker
Your agents You, with your privileges Their own terminals. Vendetta is not a sandbox.
Provider integrations (hooks, the omp extension, Claude’s Mod) Inside each agent They report status and deliver input through the provider’s own APIs
Agents in a project machine A user inside a container Docker or Podman, on a private clone
A person’s Vendetta Your account Their own folder; their agents only in containers in your rootless Podman

Enable only plugins you trust: a plugin can ask the worker to act, and the worker makes every check, but the plugin’s own process has your permissions.

A project’s vendetta.toml can declare agents and schedules. Nothing in it runs until you trust that folder.

By default nothing listens on the network. The app endpoint and webhooks bind to loopback and refuse any other address; you decide what to put in front of them. Publish the apps privately has the table.

With a new install’s config, Vendetta itself connects to nothing. Each row below is off until you turn it on.

Connects to Sends Turned on by
Telegram’s Bot API What your topics show: replies, progress, questions, media [plugins.telegram]
Discord The same, for your channels [plugins.discord]
Apple’s push service Notice titles, and up to 150 characters of each message unless preview = false; Live Activity contents [plugins.app.apns]
A browser’s push service The same notices, encrypted for that browser A browser turning on Push notifications in its Settings; [plugins.app.web_push] enabled = false turns it off for all
Your ntfy server The provider, the event, and your label; the title and the start of the reply only when [notifications] opts in. Never prompts or paths. [plugins.ntfy] url
ElevenLabs, ChatGPT, or the endpoint you name Your voice recordings, for transcription [plugins.speech.transcription] provider set to elevenlabs, chatgpt, or codex-lb. command stays local.
ElevenLabs The text of replies you listen to [plugins.speech.narration] provider = "elevenlabs". command stays local.
The rewrite model’s provider Each reply you listen to, through that provider’s CLI [plugins.app.narration.rewrite]
Anthropic’s API Model requests from Claude in your machines and people’s, with your login added by the proxy [plugins.claude-proxy]
The git hosts you list Clone, fetch, and push from machines, with your token added by the proxy [plugins.claude-proxy.git.hosts]
GitHub Sign-in, your repository list, and git through your token [plugins.github], then Connect
Your tailnet names An HTTPS request every 30 seconds to check each name answers; the plugin also runs your local tailscale [plugins.tailscale]
A container registry Pulls the machine image Project machines, unless [machines] registry = ""

Also true:

  • The web client and the iPhone app connect only to the address you publish.
  • Your providers talk to their own services as they always do, with their own logins. Two things differ: Claude’s Mod names a new session started by a Vendetta prompt with a short title from Claude’s small model, and Claude inside a machine sends no credential and reaches Anthropic only through the proxy.
  • A project machine’s network reaches the internet.
  • Telegram and Discord chats are not end-to-end encrypted.

Tokens for all of these are named in the config as an environment variable or a command that prints the token, never written in it. Commands run as an argument list with no shell. Vendetta does not log or persist a token; the GitHub token is the exception, kept in your state folder with mode 0600.

  • Every connection to the app endpoint needs a paired device’s token.
  • vendetta app pair makes one code. It works once, within 10 minutes; five wrong tries discard it, and ten failures in a minute make every new attempt wait.
  • The device’s token is shown to it once. The computer stores only its SHA-256 digest.
  • Up to 16 devices. vendetta app devices lists them and vendetta app revoke ID disconnects one within seconds.
  • Telegram and Discord accept input only from the owner ID in the config.

An approvalApproval. A provider's permission dialog for a tool call. Only you answer one: at the terminal, or for Claude Code in the iPhone and web apps with Allow once or Deny. is a provider asking before it runs a command or edits a file. Vendetta shows it and carries your answer; it never decides.

  • Who can answer. You, and no one else. Telegram, Discord, other agents, the Master, and schedules never answer an approval.
  • Where. A Claude Code permission dialog shows as a card in the iPhone and web apps, with the command or edit, why Claude asks, and Allow once and Deny. You can also answer it on the overview or at the agent’s terminal. Other providers’ dialogs, and a Claude subagent’s, are answered at the terminal.
  • While one is open, the agent takes no remote input.

Agents Vendetta starts on your computer ask before they run commands. Agents you start by hand keep whatever settings you gave them.

What an agent is started with is [harnesses.PROVIDER] in the config, its launch argumentsLaunch arguments. The arguments and environment Vendetta starts a provider with, set per provider under [harnesses.PROVIDER] in the config.. These arguments turn approvals off for that provider’s agents, so check your config for them and remove what you do not want:

Provider Starts without approvals when its table has
Claude Code args = ["--dangerously-skip-permissions"]
Codex args = ["--dangerously-bypass-approvals-and-sandbox"], which also turns off its sandbox
omp args = ["--approval-mode=yolo"]
OpenCode env = { OPENCODE_PERMISSION = '"allow"' }

Each launch saves its arguments, and restoring that conversation reuses them. See Managed agents.

Inside a machineMachine. One container that runs a project's agents on a private clone of the project., agents run without approvals: Claude runs in bypass mode and nothing asks. The container is the boundary.

  • Every agent in a machine runs as the same user and can act as any other agent there.
  • The container gets its clone, three volumes, and its proxy sockets. It gets no Docker socket, no runtime directory, no published ports, and none of your files.
  • There is no sudo inside.
  • Your Claude login and git tokens stay on the host; the proxy adds them to requests and forwards only model requests and git’s clone, fetch, and push.
  • The host treats everything a machine says as untrusted.
  • The clone belongs to the container. Do not cd into it on the host: a shell prompt that shows git status can run what the container put there.
  • An agent is identified by boot, PID, and process start time, never by its pane. A reused PID does not inherit another agent’s state.
  • Every input is pinned to that process and checked again before it is delivered, so a stale button or an old message cannot reach an agent that replaced it.
  • A refused message is never replayed later.
  • When Vendetta cannot tell whether a prompt, launch, stop, or deletion happened, it says so and does not repeat it. A schedule whose run failed or is uncertain stays stopped until you look.
  • Terminal output, titles, and paths are treated as untrusted data.
  • The Master controls agents through vendetta agent. It has no shell, keystroke, or approval command.
Kept Holds Never holds
History journals, seven days States and metadata Prompts, messages, tool arguments
Status records Each live agent’s state Prompts, answers, tool arguments
Messaging checkpoints IDs, cursors, receipts Credentials, prompts, replies
The worker’s log Each message’s handling by ID and category Content
Paired devices Token digests, names Tokens
Media agents sent, and files you sent to agents Copies, so marks and history keep working
Changes Revisions and where each comment was A comment’s text, which stays in the agent’s chat
Kept dictations Recordings not yet delivered, for a week at most

Messages in the apps live in the app plugin’s memory and on each paired device. The speech plugin keeps neither audio nor transcripts. Conversations themselves are the providers’ files, in the providers’ folders.

Desktop and ntfy alerts leave out conversation titles and reply text unless you opt in with [notifications] include_title and include_reply.

  • A person’s Vendetta never sees your agents, and yours never sees theirs. You never see their chats unless they share one.
  • Your own agents run as you, so they can read people’s folders. Their agents run in containers and see only their own clone and sockets.
  • What they take from you (Claude, git, services) goes through your proxies; your credentials never leave your account.
  • A skill or MCP server is shared only when you pick it, and a shared MCP server acts as you: whoever has it can do with it what you can.

A webhook URL runs a schedule. Each hook has a secret of at least 16 bytes, checked as a bearer token or a signature, and a rate limit. A request body is passed to the agent only when you ask, as untrusted data. See Webhooks.