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 where
Section titled “What runs where”| 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.
What listens
Section titled “What listens”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.
Outbound connections
Section titled “Outbound connections”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.
Pairing and devices
Section titled “Pairing and devices”- Every connection to the app endpoint needs a paired device’s token.
vendetta app pairmakes 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 deviceslists them andvendetta app revoke IDdisconnects one within seconds. - Telegram and Discord accept input only from the owner ID in the config.
Approvals
Section titled “Approvals”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.
On your computer
Section titled “On your computer”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.
In containers
Section titled “In containers”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
cdinto it on the host: a shell prompt that shows git status can run what the container put there.
Input goes to one exact process
Section titled “Input goes to one exact process”- 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.
What is kept
Section titled “What is kept”| 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.
People
Section titled “People”- 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.
Webhooks
Section titled “Webhooks”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.