Skip to content

Security and data handling

This page describes the security guarantees Mate provides and what data is processed during a job.

Your GitLab credentials stay out of the agent container

Section titled “Your GitLab credentials stay out of the agent container”

When you register a managed account, you give Mate a GitLab Personal Access Token. That token stays in Mate’s control plane and in the tool service that talks to GitLab for the agent. It never reaches the container where the agent runs.

The agent’s container holds:

  • a signed job credential (an opaque token that carries no permission data and no tenant identifier),
  • a short-lived, read-only clone token, used once for the initial git clone and then zeroed from the environment,
  • when push_branch is granted, a per-job scoped push token so the agent can git push. Both per-job tokens are revoked when the job ends.

The container holds no GitLab URL either, and not your account’s PAT or the key the tool service uses internally. If an agent were somehow compromised, it could not exfiltrate your account token, because it is not present.

Your LLM key stays out of the agent container

Section titled “Your LLM key stays out of the agent container”

Your workspace LLM key is held by a small sidecar (credproxy) that runs next to the job, not by the agent. The agent container gets a per-job placeholder and a loopback address. The sidecar swaps the placeholder for the real key in request headers on the way to your provider; it does not inspect request bodies, and its logs carry only method, route, status and duration. The placeholder only works for its own route (Anthropic or OpenAI), so a placeholder sent elsewhere is not swapped.

Untrusted repositories are built in a sandbox

Section titled “Untrusted repositories are built in a sandbox”

If your repository has a .devcontainer/, Mate builds the image from it. That build runs in a Sysbox system container with no secrets, no LLM variables, no mounted Docker socket and no --privileged. The sandbox is removed when the build ends, whether it succeeded or failed. If the sandbox runtime is unavailable the build fails closed; Mate never falls back to building on the host. Tenants never share build volumes.

Treat anything produced by a repository build as untrusted data.

The agent interacts with GitLab through Mate’s permission-gated tool service. On every tool call, the service:

  1. Verifies the job credential is valid and unexpired
  2. Looks up the job’s authority record
  3. Checks that the requested tool is within the job’s effective permissions
  4. Checks that the call targets the project the job was started for

The agent sees every tool, but a call outside its permitted set is refused, with a message telling the agent that the action is not part of its job here and what to do instead (for example, say in a comment that the merge request is ready). This check runs on the server side, not inside the agent process. The agent cannot grant itself additional permissions.

Write access is repository-level by design: an agent with push_branch acts like a human Developer collaborator. Protect main and release branches with GitLab protected branches.

Mate never approves its own work unless you choose to. approve_mr is an opt-in authority: an agent can approve merge requests only if you list it in the agent’s permissions:. It is never part of a default grant, and GitLab’s own rules still apply, for example “prevent approval by author” stops an agent approving an MR it opened.

Every job runs in its own container that is created at dispatch time and destroyed when the job ends. Containers are not reused across jobs or tenants. On Shared plans, the container the agent runs in operates without privileged mode and without access to the Docker socket. Image build steps run separately, in the sandbox described above.

If a job fails mid-run (for example, due to a node failure), the container is discarded. There is no resumption in v1 — the job records as errored and you can re-trigger it.

On the hosted service, the following secrets are stored encrypted using AES-256-GCM:

  • Managed account PATs
  • Workspace LLM API keys
  • Webhook signing secrets
  • Per-job GitLab API keys

Per-job API keys use column-level encryption separate from disk encryption, so database-level access alone is insufficient to read them. The encryption key is held only by Mate’s control-plane services.

Secrets are write-only in the console — once saved, a key is never displayed again. To rotate a key, overwrite it with a new value.

Data Where it goes
Repository contents Cloned into the ephemeral job container; discarded when the container is destroyed
Issue and MR content Read by the agent via Mate’s tool service; sent to your chosen LLM provider under your own API key
LLM prompts and responses Sent from the job to your provider (Anthropic, OpenRouter, an OpenAI-compatible endpoint) under your own key. Mate does not store them; the in-job sidecar only swaps the key in request headers
Job events and logs Stored in Mate’s database and displayed in the console; retained for 30 days

Mate does not send your repository code or issue content to any third party beyond the LLM provider you configured. Your LLM provider’s data handling terms govern what happens on their side.

In hosted mode, jobs and the control plane run on Hetzner infrastructure in the EU. The marketing site sets no cookies and has no analytics. See the privacy notice for details.

Every GitLab webhook call is verified against the secret token you configured (GitLab’s X-Gitlab-Token mechanism). Mate rejects any request that does not carry the correct token, so unauthorized parties cannot trigger jobs by sending forged webhook payloads.