Skip to content

Security model

Last reviewed: 16 November 2026, against main before release 2026.11.6.

In short: models run in locked-down containers and only propose. The daemon decides what takes effect, holds the credentials, and scans everything that leaves a container. Each control below says what it does not cover, and Residual risks lists what no control here solves.

This page covers what Vornik defends against, its trust boundaries, and the controls in place today. It applies to both editions; Enterprise-only controls are marked (Enterprise). Everything here is product behaviour. Where an operator's choice (proxy, model providers, host) changes the outcome, the page says so. To report a vulnerability, see Security policy.


What Vornik is, for this purpose

Vornik is a daemon on a single host, with a control CLI (vornikctl). It:

  1. serves an HTTP API and a web console;
  2. runs AI agents in Podman containers, one container per task step;
  3. runs untrusted media (documents, images, audio, video) through tools in short-lived sandbox containers;
  4. talks to the outside: model providers, MCP servers, forges (GitHub and others), chat channels (Telegram, Slack, e-mail, web chat), and an optional third-party API gateway;
  5. serves other AI assistants (Claude Code, Codex, Hermes, …) as a companion: a memory, a delegate for privileged work, and, if the operator allows it, an administrator of its own workflows;
  6. asks a person to approve sensitive actions on a paired phone.

The trust boundary contains the daemon, its database and its configuration directory. Everything else is treated as potentially hostile: network clients, agent containers, model output, tool and web content, chat users, connected assistants, and upstream services.


Threat model

In scope

Actor Can Concern
Network attacker reach the HTTP port read or change data without a key; spoof a forwarding header; exhaust resources
API client with a key call the API reach another project's data; widen its own reach
Agent container run model-directed code escape its workspace; read another project's data; reach the host, the internet or the daemon's credentials; make the daemon run a program
Prompt-injected content arrive in a web page, mail, ticket, document or tool result steer an agent into exfiltration or an unwanted write
Chat user write to a channel trigger work they are not allowed; read a task's error text or secrets
Connected assistant (companion or agent-admin key) call Vornik's tools read raw private data behind a summary; act outside its grant; approve its own requests
Holder of a stolen approver device or its cookie open approval pages approve sensitive actions
Hostile upstream (model, MCP server, forge, gateway, vendor OAuth server) shape responses crash or hang the daemon; redirect a request with secrets; plant instructions
Crafted upload be extracted or rendered read local files, fetch URLs, or exhaust the host through a parser

Out of scope

  • Physical access to the host, and root on the host.
  • Escapes from Podman or the kernel. Vornik hardens what it starts but does not defend against a container-runtime escape.
  • Network-level floods (DDoS). There are per-request limits, not traffic shaping.
  • People who may write the configuration directory. Operator configuration is inside the trust boundary (see Residual risks).

Trust boundaries

flowchart LR
    client["Network client<br/>key, session or approver device"] --> api["HTTP API and console"]
    assistant["Connected assistant"] -->|"MCP, scoped key"| companion["Companion endpoint"]
    phone["Paired phone"] --> approvals["Approval pages<br/>device-bound session"]
    api --> daemon
    companion --> daemon
    approvals --> daemon
    subgraph trusted["Trusted"]
        daemon["Vornik daemon<br/>scheduler, executor, guards"]
        db[("Database")]
    end
    daemon --> db
    daemon -->|"outbound; responses untrusted"| outside["Model providers, MCP servers,<br/>forges, chat platforms, gateway"]
    daemon -->|"podman run"| agent["Agent container<br/>untrusted"]
    daemon -->|"podman run, one-shot, no network"| sandbox["Sandbox tool run<br/>untrusted input"]

Every caller outside the daemon (network clients, connected assistants, paired phones) must authenticate to reach it. Every program it starts and every response it receives is treated as untrusted.

Where each credential lives

The daemon holds the credentials. An agent container receives only what the operator decided it needs, and a model sees only what reaches its container.

flowchart TB
    subgraph daemon["Held by the daemon: never sent into an agent container"]
        provider["Model provider keys"]
        mcpcred["MCP server credentials"]
        sealed["Credentials an assistant provided<br/>(sealed in the secret store)"]
    end
    gateway["Gateway<br/>holds third-party API credentials"]
    subgraph container["Agent container: what the model can read"]
        perTask["A short-lived per-task key<br/>bound to one project"]
        named["Named secrets the operator granted<br/>to this project (environment variables;<br/>a value may come from the credential store)"]
    end
    perTask -->|"model calls, tool calls"| proxy["Daemon proxy"]
    proxy -.->|"adds the provider key"| models["Model provider"]
    proxy -.->|"adds the MCP credential"| mcp["MCP server"]
    proxy -.->|"API calls through"| gateway
    container -->|"results, logs, artifacts"| scan["Secret scan and redaction"] --> stored[("Stored and shown<br/>in redacted form")]
  • Never in a container: model provider keys, MCP server credentials, third-party API credentials, and the credentials an assistant provided. The agent calls models through the daemon with its per-task key. That key overwrites both key variables before the container starts. If it cannot be minted, the step does not start. The daemon makes each MCP call, and the gateway adds third-party credentials. An assistant's credentials are sealed, and the assistant never sees one either. A named secret cannot carry one: its value resolves only from the daemon's environment and the operator credential store.
  • Operator credentials stay in the daemon unless the operator uses one as a named secret's value (a ${NAME} placeholder resolves from the daemon's environment, then the operator credential store).
  • The deliberate exception: what the operator puts in a container. An operator can declare a named secret and grant it to projects. It is then injected into those projects' agent containers as an environment variable, so a model running there can read it. Grant one only to a project that needs it; an empty project list grants it to every project. A role's static environment, also operator configuration, reaches its containers the same way. See Secrets.
  • On the way out, everything a container produces passes the secret scan before it is stored or shown (see Secrets below).

Controls

HTTP API and console

  • Authentication on every route except a short public list: liveness and readiness probes, /metrics (hidden on a managed instance's public listener), the login page, static console assets, the A2A agent cards, and the EU AI Act Art 50(2) detection routes. The quickstart configuration requires an API key. Credentials are checked by one ordered chain (session, signed webhook, database keys, static keys) that stops at the first refusal. Key comparison is constant-time, and so are the other secret checks (the metrics scrape token, the broker's internal key, admin key rotation): they compare fixed-length digests, so timing reveals neither a secret's content nor its length.
  • The Ollama-compatible API never forwards a provider's error text. A failed upstream call answers with a closed error class; the provider's own message, which can quote the request, stays in the daemon's log.
  • The detection routes are read-only and say little. Only three exact shapes are public: /provenance/<64 lowercase hex>, /provenance/verify and /.well-known/vornik-ai-mark-keys. They answer whether exact content (by SHA-256) was generated by this instance and on which day, whether a mark is genuine, and which public keys sign marks. They never return content, a task, a project or the channel, and a failed verification does not say which part failed. A hash must be known to ask, so the ledger cannot be enumerated. Public routes skip the general per-IP limiter, so each applies its own: 5 requests per second per address, burst 10.
  • Admin class is decided once per request. One decision function governs the operator surface (configuration, reloads, daemon-wide repairs); a second decides who may read error text and logs (operator, scrubbed, or denied, with denied as the default).
  • Per-project scoping on every project resource. A project-scoped key that asks for another project's object gets "not found", not "forbidden", so existence does not leak.
  • Agent keys reach only the agent route set, on every listener (TCP and the unix socket), and cannot post as the operator.
  • A database key's flags bind it on every route. A key minted with vornikctl key create reaches its project's memory only with memory_read (reads) or memory_write (writes, including document extraction into memory). With a workflow list it reaches only the A2A routes of those workflows. It cannot create, list or change keys: key management is for static keys, admin keys and the console.
  • A published A2A expert can be limited to what it may say. A workflow's a2a.answer block sends the caller only the listed keys of one named JSON output, only from a run that completed, read under 64 KiB before it is parsed and capped at maxBytes. Fenced code is refused or stripped, and each citation must be a clean path under the answering role's memorySearch.sourcePrefixes. Any failed check sends nothing, and the caller sees the run as failed. That role's search returns only sources under those prefixes, whatever the request asks. What it does not cover: a model can paraphrase anything it retrieved, so the boundary is what the role's memory holds. Put only what may be disclosed in an expert's project, and keep private material in another one.
  • A role can be capped at a sensitivity tier. With memorySearch.maxSensitivity: public, the role's search returns two kinds of chunk only: chunks an operator set public, and checked files. A checked file is one under memory.public_source_prefixes (default docs/public/) whose bytes the daemon matched against the trusted branch. A source path a writer names counts for nothing. A chunk with no tier counts as confidential, and a chunk the operator sets confidential is kept out. vornikctl doctor (memory_sensitivity_cap) states how many chunks each capped role can retrieve. What it does not cover: companion and console recall have no role policy and are not capped.
  • An A2A caller key is bounded. Each task it submits records the key.
  • A submit is refused once the key's attributed spend reaches its budget_cap_usd (402), or once it has created the workflow's a2a.dailyQuotaPerKey tasks since 00:00 UTC (429; 50 unless set).
  • A key with a workflow list and no rate limit of its own gets 1 request per second, burst 10.
  • A spend or count that cannot be read refuses the submit.
  • vornikctl doctor (a2a_corpus_walk) names a caller key whose A2A tasks retrieved more than 500 distinct memory chunks in the last 24 hours. That volume is a sign the caller is walking the expert's corpus. It reports after the fact and blocks nothing; the quota and the rate bound how fast a walk can go.

What it does not cover: concurrent submits can pass the quota by up to 10, and spend from before 2026.11.2 is not attributed. - Request bodies are size-capped and strictly decoded. The configuration dump redacts every credential-shaped field; a test plants a marker in every string field of the configuration and requires each credential-shaped one to come back redacted. - Same-origin checks on every state-changing console request, through one shared gate; Secure cookies on HTTPS. - A content-security policy on every console response. It admits only this origin for scripts, and an inline script only by the SHA-256 of its exact text, computed at start from the embedded templates (a console whose hashes cannot be computed does not start). There is no 'unsafe-inline' or 'unsafe-eval' for scripts, no inline event handler, and htmx neither evaluates attributes nor runs scripts from swapped HTML. What it does not cover: a hash admits that exact text anywhere on the console, so an injection could replay one of the console's own scripts in another place; inline styles remain allowed. - Real client IP behind a proxy is taken from the configured header only when the immediate peer is in the configured trusted-proxy list; otherwise the peer address is used. A trusted-proxy entry wider than one address logs a warning at startup. Rate limits and login lockouts key on this value. - Managed hosting (hosting.mode: managed, for hosted instances; off by default) splits the daemon into a public listener and an operations listener. Administrator access exists only on the operations listener, which must bind a loopback or private address. - The public listener refuses every admin-class key, in any header it can be presented in, before routing. It serves no metrics. - The instance owner. An administrator's browser session on the public listener is the instance owner. The owner may use a closed list of operator surfaces and no other: - the project wizard and the template gallery; - MCP OAuth connections: connecting a server, and on a project's MCP tools page seeing its sign-in and disconnecting it (an instance-wide sign-in is removed for every project that shares it, and the page says so); - the operator audit; - the Credentials page; - creating, rotating and revoking keys on a project's Keys page; - choosing which roles of a project may call an MCP server's tools, on its MCP tools page; - reading the operator console's observation pages, never changing anything through it; - reading the instance's swarms and workflows (the lists, each definition and a workflow's graph), never changing them, which is valid while the instance hosts one customer; - connecting the instance's model provider (/ui/model-provider). The provider is checked before saving under managed mode's own dial rule (public addresses, plus the vouched model gateway names), so the page cannot reach the instance's private network. The key is sealed in the credential store and never shown again. Each change is audited with the provider's host, never the key, and takes effect at the restart the hosting service performs.

The console pages that show the daemon's configuration, its MCP server
catalog, admin keys or accounts stay closed to the owner, even for
reading.
  • Owner actions are recorded. Each key action is audited, and the key list shows who made each key. A key the owner makes is a full key for its project, which cannot manage keys, until revoked. A tool grant is recorded as an applied proposal naming the owner, which the operator can roll back.
  • Start-up refusals. Managed mode refuses to start with authentication off. It also requires the per-IP request limit and a narrow trusted-proxy list, and starts no stdio MCP server.
  • Outbound limits. Model endpoints must be public addresses, except the listed model gateway names, which may resolve to private addresses but never to loopback or metadata addresses. Every MCP server it dials must be a public address, with same-host redirects only.
  • Binding a managed instance to its customer. A managed instance gets its owner and models from one setup operation on the operations listener, never from the public one.
  • Idempotent, with a fixed owner. A repeat writes nothing; another owner is refused, and so is another issuer or client id once an owner is bound. Only the current instance_admin key may call it.
  • Checked before it writes. It probes the issuer's discovery and requires every listed model to be served by a gateway named in hosting.model_hosts.
  • The daemon owns its configuration file, not its directory's other files. Provisioning writes the configuration as the daemon's user and makes /etc/vornik writable by the daemon's group with the sticky bit, so setup can replace the configuration while the files root owns there (the provisioning marker, the shipped example) cannot be removed or replaced by the daemon.
  • The owner's login is OpenID Connect against the hosting service's issuer:
    • PKCE (S256) and a nonce on every sign-in, held in a cookie bound to that sign-in's state;
    • an ID token checked for its signature against the issuer's published keys, issuer, audience (and azp when the audience names others), expiry, issue time and nonce;
    • the issuer reached only through the outbound guard, with every response capped at 1 MiB.
  • Replacing the operations credentials. The instance_admin key and the metrics scrape token are replaced through an overlap: the old and the new are both accepted until the old is retired.
    • The new value is returned only sealed to the caller's post-quantum hybrid (X-Wing) key.
    • Only the current instance_admin key may rotate or retire: the one the config file lists, not the previous one, and not a key retired but still accepted until the restart. So a stolen old key cannot lock out the current one or mint a new one.
    • A change takes effect at the restart the control plane performs.
  • What it does not cover:
    • a stolen current instance_admin key can rotate it away (it is the instance's administrator credential by design);
    • authorization-code single-use is the issuer's job;
    • models from the hosting service's gateway are classed "provided" and need no per-destination approval, on the strength of the owner's sign-up consent and the service's terms, which the instance cannot check itself.
  • Operating a managed instance. These run on the machine as root, or on the operations listener; none is reachable from the public listener.
  • Upgrades:
    • Refusals before anything changes. An upgrade refuses an unsigned package (the signature is checked on a private copy of the file and enforced again by the package manager at install), a downgrade, and an unaccepted licence version.
    • Order. It waits for idle, stops, snapshots, installs and starts.
    • Rollback. A failed start rolls back by itself. Once the new version has started, the upgrade is final, because it may already have accepted writes.
    • A newer database is refused. A daemon refuses to start on a database a newer release migrated, so an older binary never runs against a schema it does not know.
  • Backups. Every backup archive is readable by its owner only. A restorable backup also carries the secret store's key; it is as sensitive as the secrets. A restore writes secrets only into the directory provisioning created and never through a link inside it.
  • The owner export:
    • Contents. It leaves out the secrets, redacts the configuration, and drops the rows of every table holding keys, tokens or sessions. A test classifies every table, so a new one cannot reach an export unexamined.
    • Who downloads it, and from where. Only the instance owner, signed in, on the public listener: not the hosting service's administrator key, not another role. The link carries no credential.
    • What is served. An object the daemon names from its own instance id, for 7 days from its registration. An unknown or expired id gets the same answer, and at most two downloads run at once.

Configuration integrity

  • Every request-derived name joined into the configuration or workspace tree (project, swarm, workflow, schema, file) is cleaned and confined under its root by one path helper; separators, ., .. and empty names are refused.
  • Every read-modify-write of the daemon configuration file goes through one file lock, so two subsystems cannot overwrite each other's changes.
  • Applying a configuration change records the deployed file it replaces first, so every apply can be rolled back; an apply that cannot record it is refused. No request commits to git on the host.
  • The configuration assistant sees a redacted snapshot: secret-named values and lists are withheld, and a file it cannot screen fully (a secret reached through a YAML alias, more than one YAML document) is refused rather than shown. A tokenised calendar URL (a Google Calendar secret address, an Outlook published calendar, an iCloud public calendar) anywhere in a project's files is refused until it moves into a secret; other providers' feed URLs are not recognised.
  • One daemon writes configuration. Interactive writers (setup, key rotation, the console's edit pages, workflow proposals) change files only on the daemon that holds the config-writer lease; another daemon answers 409 and changes nothing.
  • A reload never drops a running project it cannot read. When a running project's file stops decoding, the reload keeps that project's last good definition, applies every other change, and reports the refused file; vornikctl config reload exits non-zero.

Identity, chat channels and who sees what

  • People are user accounts; API keys, chat identities (Telegram, Slack, e-mail) and devices map to accounts. Single sign-on via OIDC is (Enterprise).
  • Chat channels have sender allowlists that fail closed when empty (a Slack direct message is gated by the sender list, not the channel list).
  • Non-operators see scrubbed task text. Task errors, status text, input prompts and output excerpts reaching a chat user who is not an admin-linked operator in a private chat are passed through a scrubber that withholds secret-bearing lines and replaces e-mail addresses, home paths, IP addresses and the host name. The same rule applies to the chat model's status tools.
  • Every AI-generated chat reply carries the EU AI Act Art 50(1) disclosure for its channel; a turn whose disclosure cannot be delivered is refused.
  • The web chat shows exchanges, never tool results. A reply runs in the background, bound to the browser session that asked (its chat cookie and whether it is an operator view) and to the project: another browser, view or project asking for that reply gets "not found". The page renders model text only through the server's escaping and a markdown renderer that drops raw HTML; the deploy gate waits for a running reply.

Approvals and approver devices

  • Sensitive actions (an assistant's new connection or credential, a widening of its reach, a proposed write) are approved on a paired phone, not in the requesting channel. Pairing is started by the operator from vornikctl.
  • A device's session cookie rotates on every decision; a copied cookie dies at the device's next approval, and a browser riding a device's approvals raises an alert. Restoring a device is an operator action and is alerted.
  • An approval binds to the hash of the exact arguments shown, computed over a canonical form that refuses duplicate keys, so the approver cannot be shown one thing and approve another. Choice cards accept only a choice.
  • An approved change that fails to apply for a reason that may pass (a busy project, for example) is retried at most 60 times, about an hour. It is then recorded as failed, and the requester is told, so a request never waits unseen for ever.
  • Approval notices pushed to a channel carry no content, only a link.
  • A paired device can also receive browser notifications (Web Push). A notification names the event, never what is asked. It is encrypted to that device and signed with a key derived from the secret store.
  • Vornik posts only to the browsers' own push services: four fixed hosts, over https, following no redirect.
  • The one approval page that runs a script is the notifications page, and the script comes from Vornik itself. Its notification worker controls no page.
  • Revoking a device deletes its subscription.

Agent containers

  • Every container runs with all Linux capabilities dropped, no-new-privileges, a non-root user, and labels for discovery and reaping. Only the pinned agent image may be started. The scripts that drive the container are owned by root, so an agent cannot rewrite them.
  • Read-only root and a PID limit (runtime.agent_read_only_root, runtime.agent_pids_limit; off by default, always on in managed hosting). With the read-only root, an agent writes only its mounts, /tmp, /var/tmp and its home (disk-backed volumes removed with the container) and two small bounded tmpfs (/run, /dev/shm); the PID limit bounds a fork bomb. A periodic sweep removes containers, and their volumes, that a crash left behind, only once their task has finished. Without the settings, the PID limit is the host podman's own default.
  • Network policy per role. The default is daemon-only: no network device at all, with the daemon reachable over a unix socket for tools and model calls. Roles that need the internet opt in to an isolated egress namespace; host networking is available but discouraged.
  • Per-task credentials. Each task step gets its own short-lived, project-bound key. If minting it fails, the step is refused; it never falls back to a static or provider key.
  • Workspaces are git worktrees. Daemon git commands pin the git directory and work tree, read a global git config composed by the daemon (hooks, filter drivers and core.hooksPath dropped), and never read state an agent can write. Warm containers mount no project. A task the daemon cannot give a worktree fails before any container starts.
  • Inputs are staged only from the task's own project; outputs are harvested through one pinned directory handle, so a running agent cannot swap files under the daemon. Symlinks that leave the workspace are refused. The read tools (file_read, read_many_files) open through the workspace root and check the opened file, as the write tools do, so a file swapped for a symlink cannot be read outside the workspace.
  • Credentials stay out of containers. Third-party API credentials live in the gateway, MCP credentials in the daemon, and an agent's tool arguments carry none. The exceptions are the ones an operator configures; see Where each credential lives.

No daemon surface chooses a program

  • Exactly one part of the daemon may start a process, and it runs a closed set of program kinds: the pinned agent image (with an allowlist of flags), container control verbs, git under a registered workspace root, the git HTTP backend, and a stdio MCP server or CLI model provider that only the configuration loader can define. Each kind parses its argv against a closed grammar before a process exists.
  • No request, UI form or configuration write from a request may add or alter a stdio MCP server. Host diagnostics (podman, systemd, journal) run only in vornikctl doctor on the host, never in the daemon.
  • An architecture test fails the build when a daemon-linked package gains the ability to start processes outside that one place.

Untrusted media: sandbox tool runs

  • Extraction (PDF, OCR, audio, video), document rendering, and voice (speech-to-text, text-to-speech) run as one-shot containers of the pinned agent image: no network, read-only root, a small tmpfs, a pids limit, all capabilities dropped, inputs mounted read-only, and per-feature memory, CPU, time and input-size limits. Inputs over the limit are refused before a container starts. Output is bounded by a per-file size limit plus a once-a-second sample, not a disk quota.
  • Renderers cannot read local files, fetch, or run script. ffmpeg reads only the uploaded file, through a file-only protocol list and a short list of permitted formats.
  • Archive extraction is guarded against zip bombs, oversized expansion, too many entries, and symlinks that escape the destination.

Prompt injection and untrusted content

  • Third-party content is scanned on the way to a model, including MCP tool results, for injection attempts, credential leakage and encoded payloads. Findings name the rule that produced them.
  • Content from outside is wrapped in an untrusted-content envelope whose close tag the model can see; the wrapper fails closed on malformed or over-encoded input.
  • Taint lineage. Each autonomous step records whether it consumed untrusted content. In enforce mode, a write by a tainted task parks for operator review with its sources attached. The default mode is advisory.
  • Memory ingest gates run on every deposit: secret scan (a mostly redacted "secret dump" is rejected outright; besides the typed patterns, the labelled key: value shape and long high-entropy runs, memory alone also catches a random 24 to 39 character token with mixed case and digits and no label, except a Google Places ID; a token of one case, without digits, or shorter is not caught), per-project deny patterns (substring, not regex), optional injection detection, dedup and size checks. A memory firewall attaches sensitivity, role, purpose and expiry policy to chunks and audits every retrieval decision. A connected assistant's deposits land unverified and low-confidence, and its corrections cannot overrule an operator's.
  • Learned skills are never drafted from goals whose words came from a third party (webhook, forge, chat or A2A).

Secrets

  • A secret detector (known token shapes plus an entropy heuristic) runs at every persistence and display boundary: task results, tool audit, container logs, artifacts, transcripts, chat notices and memory. Credential-shaped findings are redacted; inbound webhooks with a secret are blocked. Heuristic findings are counted but no longer rewrite stored artifacts, because they produced no true positives in production.
  • Results are validated before redaction, so redaction cannot corrupt a result into a schema failure; everything stored or forwarded is the redacted form.
  • Outbound tool arguments are scanned too. For an assistant-administered project a credential-shaped value in a tool argument blocks the call; a refusal names the field, never the value.
  • Memory recall queries are scanned before they are stored. The recall audit keeps the query text in its redacted form.
  • vornikctl secrets scan-history rescans stored history (tool audit, step prompts, transcripts, task messages) and redacts what it finds.
  • Credentials an assistant provides are sealed at rest with a key file the operator must back up; the doctor checks that the key opens them.
  • Operator credentials (values the configuration references as secret://NAME) are sealed the same way. They are written from the console's Credentials page, the MCP form, or vornikctl credential through the admin API, which takes an admin-class API key only and refuses when API authentication is off. The value is read once and never logged, echoed or audited; each write records who, from where, and the name.

Forge review publication

  • What a review publishes is scanned. Before Vornik posts a pull-request review or comment, it scans the whole text it will post (the review, the quoted request and any CI notice) with the secret detector, plus rules for HTTP Basic credentials: an Authorization: Basic header, a base64 user:password and its decoded form. Each match is replaced by [REDACTED:<type>] and the rest is posted. Without a detector, the review is withheld and a notice is posted instead.
  • A review covers the whole change, or none of it. An empty diff is refused, and so is any GitHub response over 1 MiB: before, a larger diff was cut and reviewed as if it were whole. A pull request with no new commits since the last review stays a no-op.
  • A review is pinned to the commit it reviewed.
  • CI artifacts reach a review masked. Forge unpacks an uploaded artifact in memory, with a cap on uncompressed size and file count, then masks every file and file name with the secret detector before storing it. A rescan must find nothing; otherwise, or without a detector, the content is withheld. A SARIF file is shown only as its level, rule, file, line and message, never its code snippets or fingerprints. The text reaches a model marked as untrusted data.
  • What it does not do. It cannot take back a credential already committed to a public repository; rotate any exposed credential. Detection matches known shapes, so a credential in a shape it does not know can still be published.

Outbound connections and SSRF

  • Every outbound client has a timeout and a read cap.
  • A dial guard refuses loopback, link-local, private, special-use and reserved ranges, including IPv6 transition forms that embed a blocked IPv4 address (NAT64, 6to4, IPv4-compatible), and the cloud instance-metadata addresses (IPv4 and the IPv6 ones in private ranges) even where private ranges are allowed. A hostname is judged by the address it resolves to, and guarded clients ignore proxy environment settings. One list decides for every guard. An operator-listed allowed host is an explicit vouch and bypasses the list, metadata addresses included. Operator-listed private ranges are allowed only where a feature needs them.
  • An agent project's approved API or MCP server reaches a private address only on a host the operator names in agent_admin.private_api_hosts, and only over https. A listed host still never reaches loopback, link-local or metadata addresses, each API or server still needs its approval on an approver device, and a managed instance refuses the setting. Before approval, a failed tool listing on a listed host tells the agent only that it could not connect. test_connection reports a refused address as blocked_private_address.
  • Redirects that would carry secrets are refused; gateway redirects stay on the same origin.

MCP servers

  • OAuth 2.1 for remote MCP servers: discovery, dynamic client registration, PKCE, resource indicators, refresh. A stored grant is bound to its resource audience, so a token minted for one path is not presented to a sibling path. Token requests do not follow redirects. Write scopes for daemon-wide servers must be named in configuration, and the CLI says what it withheld.
  • Every stored OAuth token is sealed at rest with the secret store key file, bound to its project, server and field, so a value copied to another row does not open. A token found unsealed in the database is never served, and the doctor reports it.
  • A server can be required to declare its tools; it is then refused when it advertises a mutating tool that is not in its allowlist.
  • A configuration reload that removes a server cannot be undone by a connection that was still dialling.
  • On a managed instance, sign-ins go through the hosting service's OAuth router, which forwards an authorization code only to the browser of a signed-in member who started that flow:
  • every flow starts at the router;
  • the authorization response's issuer is checked (RFC 9207) before any token is requested;
  • a provider whose metadata names another issuer than its own address is refused;
  • a grant wider than requested is refused, and the token revoked where the provider allows it.

A self-hosted daemon checks the issuer where the provider supports it, and logs instead of refusing the last two cases, so working connectors to non-conforming providers keep working.

Assistants: the companion, the broker and agent administration

  • A companion key is bound to one project, optionally to a list of workflows and a budget. It may use five routes, each matched by its exact path, never a prefix:
  • the companion endpoint;
  • the capability list;
  • a task's live view, for a task in its own project;
  • the plugin hooks' hint catalogue, for its own project;
  • the hooks' hint outcome upload, for its own project. The upload holds hint ids and a followed flag only, and refuses any other field.

The hint report, which shows each hint's follow rate, is an operator route and refuses companion keys.

A memory key can be minted without any task tools.

A key is offered only the tools its scopes allow: memory read and write, skill read, write and approval, and delegation. A call outside them is refused before its handler runs, and each handler checks the scope again. An AWS DevOps Agent investigation is one such client. Its recommended key reads memory and approved skills only, and AWS asks customers to allowlist read-only tools as well. What it remembers, with a wider key, lands as a note under the memory gates, never as a verified fact.

Each companion key may make 5 requests a second, with bursts of 50, unless the operator changes api.rate_limit.companion_key.

A CI job may authenticate as a companion key without holding its secret: the operator binds the key to one GitHub Actions workflow (the repository's numeric id and name, the branch or tag ref, the workflow file, the events), and the job presents the ID token GitHub issues to its run. Vornik checks the token's RS256 signature against GitHub's published keys, its issuer, expiry, nbf and iat, that it carries exactly one audience equal to the trust's, and every bound claim exactly; there are no wildcards. The key must still be a live companion key whose owner is not disabled. Any failure is a 401 that counts toward the per-address lockout, never a fall-through to another credential. pull_request is refused as an event (its ref never names a branch); pull_request_target is allowed only when the operator names it, because it serves the base branch's identity to a job that may run a pull request's code. - The plugins keep hint state only in the plugin's own data directory (or the user's runtime directory when the user owns it), never in a shared temp path, and refuse a state directory that is a symlink or that another user owns. A hint's text comes only from the catalogue; nothing from a tool's input or output is put into it. The Hermes plugin (0.23.1) reads, for a review or an ingest, only the files the model names: regular files under Hermes's task workspace, never through a symlink or a hard link, checked again on the opened file, at most 20 files and 2 MB. It refuses credential files (.env and its variants, .envrc, in any case) and anything under the Hermes home, and refuses when Hermes does not say where the workspace or its home is. Its memory key may start the review and ingest workflows in its own project within the key's budget; neither reaches a credential, mail or the broker project. - Broker projects let an assistant ask for privileged work (read my mail, check my calendar) without ever holding the credentials or seeing raw data. A broker workflow takes typed, bounded inputs and returns one schema-checked, scanned document; error text is reduced to a closed class. - Writes are proposals. A broker workflow may only propose a write; a person approves the exact arguments; a single worker performs it once and never retries, recording "unknown" when the outcome is uncertain. Writes are off until the operator enables them. Standing grants for repeated writes are bounded in days, uses and number. - Agent administration lets an assistant build projects and workflows in its own namespace. Its key lives in a file only the user can read, read by a bridge command, so no assistant configuration holds it. For an assistant that can run shell commands, connecting checks that Vornik runs as a different OS user. Every credential and every widening of reach is approved on the phone; the assistant never sees a credential. Refused calls are recorded and shown. - Completion pushes to an assistant carry only ids and closed states, and refuse loopback, link-local and unlisted private addresses.

Data protection

  • Mirrored repository files follow their disclosure marking. A project may mirror Markdown files from its repository into memory; a file marked disclosure: never is not mirrored, and a mirrored file re-marked never leaves the corpus at the next sweep.
  • Retention windows per data class, with floors for audit evidence (tool audit is kept at least six months, as the AI Act requires deployers to keep logs) and an AI-disclosure log that is never pruned.
  • Data-subject rights: a register of whom a record concerns, identity-verified access and portability reports, erasure with a preview, and a breach ledger with the 72-hour clock.
  • Erasure. Exclusive records are deleted. Records that also concern other people are redacted, not destroyed, and re-embedded.
  • Shared transcripts. In a multi-person conversation, the messages the person wrote are replaced by a dated removal note under a pseudonym. Their known identifiers are masked in everyone else's messages and in the instructions of tasks those messages started. No model rewrites anyone's words. What remains of the person in others' messages is kept only on a ground the operator assesses and records for each request.
  • Chat channels. A channel's stored conversation is deleted or masked the same way, and deleted in full where the channel does not record who wrote each message. Every daemon node checks a version on the stored row before serving its cached copy, and saves only over the version it read, so an erased conversation is neither served from memory nor written back.
  • Deferred, not claimed. A record a running task still uses, a conversation that keeps changing during the erasure, and a session held only in memory (single-process installs) are deferred. The request is then reported as not fully actioned, not marked done.
  • AI Act Art 5: the vision agent refuses identification, emotion inference and inference of sensitive characteristics.

Supply chain and releases

  • Release and Community-export builds start from empty module, build and tool caches and run go mod verify before building. govulncheck and CodeQL run in CI.
  • Only the pinned agent image may run. An image provenance record lets the daemon compare running images to a release; a packaged host without the record reports that it cannot verify rather than passing. Locally built images are recorded by source commit only, because their digests differ per host.
  • The Community export is scanned for leaked private material before publication.

Availability

  • Request size caps, per-project rate limits on internal endpoints, bounded queues that drop and count rather than block, bounded mail polling, and panic recovery around provider SDK calls.
  • Log forwarding with TLS and CA pinning is (Enterprise).

Residual risks

  1. Operator configuration is trusted. Whoever can write the configuration directory can point Vornik at any model, MCP server or channel. Protect it like /etc.
  2. Model endpoints may be private. Configured chat and embedding endpoints dial through the guard with private ranges allowed, so a local or LAN model server works: link-local addresses (the cloud metadata service) and redirects to another host are refused, but a configured endpoint can reach any loopback or private address. Use network-level egress filtering if configuration is partly delegated.
  3. Rate limiting is per feature, not global. The general API's per-IP limit (api.rate_limit.per_ip) is off unless configured; managed hosting requires it. Without it the API relies on a small set of authenticated keys. IP-based defences are only as good as the trusted-proxy list.
  4. Prompt injection is mitigated, not solved. Scanning detects and wrapping isolates, but a model can still be misled; the structural defences are scoped keys, schema-bound outputs, approvals for writes and, in enforce mode, taint parking.
  5. Approvals are only as good as the approver. An approver who approves without reading defeats the gate; nothing in software prevents that.
  6. Sandbox output is bounded by sampling, so a run can overshoot its output cap by up to one second of writes.
  7. Marks on AI-generated content can be stripped, and an edited copy is not recognised (EU AI Act Art 50(2)). Marks are signed metadata and a ledger keyed by the exact bytes; there is no embedded text or audio watermark, so synthetic voice replies are off by default. Details: AI transparency.
  8. Image signatures are not verified. Pin images by digest or use a private registry with content trust.

Reporting

See Security policy for how to report a vulnerability and which versions are supported.