Peck security overview
DEVLIN.AI LLC · November 2026 · for security reviewers
Peck is a desktop app for macOS and Windows that runs AI coding agents (Claude Code and Codex), each in its own container on the person's computer. An optional iPhone app and relay let the person steer it from elsewhere. This document describes how Peck is built to be safe, what leaves the computer and what Peck does not protect against.
1. Architecture
┌──────────────────────── the person's computer ─────────────────────────┐
│ Peck (Electron main process) │
│ ├─ settings, keychain-encrypted secrets, audit log (private folder) │
│ ├─ local API for the in-container `peck` CLI (per-workspace token) │
│ └─ container engine (Docker Desktop / OrbStack / Lima / WSL) │
│ ├─ workspace container: agent + project worktree + firewall │
│ ├─ workspace container: … │
│ └─ Orchestrator container: read-only dev folder + firewall │
└──────────────┬──────────────────────────────────┬──────────────────────┘
│ agents → the person's AI provider │ (optional) E2E-encrypted
│ (Anthropic / OpenAI / Bedrock / │ relay on Cloudflare
│ Vertex / company gateway) ▼
▼ iPhone / other computers
Peck doesn't pay for, resell or route model usage. The agents call the person's AI provider directly, under the person's own account.
2. What leaves the computer
| Destination | When | What |
|---|---|---|
| The person's AI provider | While agents work | The prompts and code the agent sends, under the person's account |
| GitHub | When GitHub is connected | Sign-in, clone and push of the person's repositories, pull request status |
| Package registries and approved domains | From inside containers | What the project installs; only domains on the firewall allowlist |
Context7 (mcp.context7.com), a documentation service |
While agents work, on by default | Peck's default settings give agents Context7 as a tool, so it is allowed in every workspace and an agent may send it documentation look-ups (library names and questions). It is a third party that the agent talks to directly. It can be turned off in Settings → Claude setup, or per project. |
GitHub's published address list (api.github.com/meta) |
When a workspace's firewall is applied, at most once a day | A request with no sign-in, to learn GitHub's network ranges for the firewall. GitHub sees the IP address. Peck does the same with Stripe's list only when api.stripe.com is allowed. |
| GitHub Releases | Update checks, unless turned off by policy | Download requests |
| Cloudflare (Peck relay) | Only when remote access is on | End-to-end encrypted messages; device identifiers, timing and sizes. Cloudflare sees IP addresses. |
| Vercel, Supabase | Only when linked | API calls for the linked project |
Peck has no telemetry, analytics or crash reporting, and none of its dependencies provides them.
3. Threat model
Peck assumes the agent is hostile. A prompt injection in a README or a package can take an agent over, and agents run with permission prompts off by default. Peck's controls therefore have to hold without the agent's cooperation.
| Control | What it stops |
|---|---|
| A container per workspace | The agent reaching files on the computer outside its own project. Project configurations can't add host mounts, privileged mode, the engine's socket or extra capabilities. |
| No root inside the container | The agent changing the firewall or the system. sudo is removed after every start. |
| Outbound firewall (allowlist) | The agent sending data to arbitrary hosts. Everything not on the allowlist is refused, DNS goes only to the container's own resolver, and IPv6 is filtered or the container doesn't start. |
| Allowlist read from the computer | The agent allowing its own domains. The project's allowlist file is read from the committed default branch, never from the agent's working copy, and new domains need a click by default. |
| Shared git folder clean-up | The agent leaving hooks or settings that would make git on the computer run a program. This cleans up after the fact; see "The shared git folder" below. |
| Orchestrator lockdown | The Orchestrator, an optional agent that works across projects, writing everywhere. It sees the projects folder read-only and has its own firewall. |
| Local API identity | One container acting as another. Each container has its own token, and secrets are never returned to containers. |
| Settings only the person can change | The agent relaxing a safety setting. Agents can't change firewall, remote access, host access, permission or account settings. |
| Organisation policy | The person, or an agent, changing what IT decided (section 7). |
Approving domains without a click. One setting, firewall.autoApprove,
makes Peck grant an agent's domain request for its workspace without a click.
It is off by default and has no switch in Settings. It can be turned on only
by editing Peck's settings file on the computer, in a folder containers can't
see, and Peck refuses any firewall change that comes from an agent. Every
approval is written to the activity log. An agent that the person lets run
directly on the computer, outside a container, can edit files there,
including this one. The policy setting firewall.agentRequests: "off" stops
domain requests altogether, whatever this setting says.
The shared git folder. A project's shared git folder is writable from its
containers. Peck gives each container an empty hooks folder. It removes
settings that would make git on the computer run a program, and undoes
redirects such as a changed commondir, at every container start and stop
and within about two seconds of a change while the container runs. A setting
written and used inside that window, or a kind of setting Peck doesn't
recognise, is not caught. If Peck can't check the settings, the workspace
says so.
4. Credentials
- Claude subscription sign-in: Peck never reads, copies, refreshes or relays it. Claude Code handles it inside the containers, and an automated test enforces this.
- ChatGPT (Codex) sign-in: copied into a workspace only when the person clicks "Use the ChatGPT sign-in Peck has". Each copy is written to the activity log.
- Secrets stored on the computer: the Claude API or gateway key, the
GitHub token, MCP server secrets and project environment values are
encrypted with the operating system's keychain, in a folder containers
can't see. Each reaches a container differently:
- Claude API or gateway key: passed through standard input and written by the container user to a file only that user can read, in the workspace's own storage. It never appears in command lines, environment variables or logs.
- GitHub token and MCP server settings: each is written as a short-lived file, readable only by its owner, into the workspace's project folder. The container's setup script moves it into the container's own private files, then deletes it, and Peck deletes it again when setup ends. While setup runs, anything already running in that container as the same user could read the file.
- Project environment values: written to the project's env file
(
.env.localby default, readable only by its owner and kept out of git), where the project's own programs read them. The agent can read them too (section 8).
- GitHub inside containers: each workspace holds a GitHub token (section 8).
- Logs: Peck redacts anything shaped like a token from every line of its log.
5. Remote access (optional)
Remote access is off by default. Each device has a P-256 ECDSA identity key kept in its operating system's keychain. Sessions use ephemeral ECDH P-256, HKDF-SHA256 and AES-256-GCM with counter nonces. The relay forwards opaque frames and can't read them. Pairing a device needs a click on the computer; pairings last 30 days and renew while in use, and any device can be revoked at once. Terminals open only from another of the person's computers, never from a phone.
The relay logs no IP addresses itself. Cloudflare's request logs, which include IP addresses, are kept for a sample of 1 in 100 requests. For each computer, the relay stores only the computer's relay identifier, the identifiers of revoked devices and hourly file-transfer counts for the last 24 hours.
6. Updates and build integrity
- Installers are built by GitHub Actions. macOS builds are signed with an Apple Developer ID and notarized; Windows builds are signed through Azure Artifact Signing.
- The updater checks each update's SHA-512 hash before installing it.
- Bundled binaries (the Docker CLI, buildx and Lima) are checked against pinned SHA-256 hashes, and the Lima guest image is pinned by digest.
- CI actions are pinned to commit hashes, and workflows are read-only by default.
- Dependabot, a dependency audit and Semgrep static analysis run on every change. Any high or critical advisory blocks a merge, except the one listed in section 8.
- Each release includes a CycloneDX software bill of materials (SBOM) for the app's npm packages. The bundled Docker CLI, buildx and Lima are not in it.
- Steps for verifying a release's signatures and hashes are available from security@devlin.ai.
7. Admin controls
An organisation can deploy a policy.json file through its device management
(MDM). The file can:
- turn off remote access, agents on the computer itself, the Orchestrator, automations and agents' domain requests;
- pin the relay;
- limit which GitHub owners and Claude account types can be used;
- set Claude's permission mode;
- add domains that are always allowed;
- require the iPhone app lock;
- set how updates behave.
If Peck can't read the policy file, it fails closed. On macOS and Linux, Peck
ignores a policy file that the person owns or can write to. On Windows, Peck
applies the file at %ProgramData%\Peck\policy.json as it finds it, because
it can't check Windows permissions itself, so IT must create the Peck
folder so that only administrators can write to it.
Claude Code's managed settings files and Codex's managed config file on the computer are copied, owned by root, into every container. Settings delivered through a device-management profile or from the vendor's servers are not files, so they are not copied.
Peck keeps an activity log of approvals, pairings, workspaces, requests from paired devices and policy loads for 12 months. It can be exported from Settings.
8. Known limitations
- DNS tunnelling: a container can resolve any name through its allowed resolver, so data could be encoded in DNS queries.
- GitHub token in containers: each workspace holds a GitHub token that can reach the person's other repositories, not only the workspace's own.
- Build-time mounts: mounts that a devcontainer feature or base image adds exist during the image build, before Peck's check removes them.
- The project's own secrets: an agent can read the project's
.env.localand anything else in its project folder. - The shared git folder is cleaned, not walled off (section 3).
- Submodule hooks: a submodule's hooks folder is not replaced the way the main one is; its git settings are cleaned.
- Firewall re-apply: while Peck re-applies a container's firewall, for example after an approval, new connections from it are briefly refused.
- Containers left running through a Peck update keep their previous firewall rules until they restart.
- DNS in Compose workspaces: on a container engine whose Docker doesn't list its upstream DNS servers for Compose networks, DNS in a Compose workspace may not answer.
- Approvals without a click: if the person turns on
firewall.autoApprove(section 3), agents' domain requests are granted without a click and written to the activity log. - Windows policy file: Peck can't check who may write
%ProgramData%\Peck\policy.json. That depends on IT locking the folder. - Services on the computer: a container can reach only Peck's own API and the local MCP servers' ports on the computer. The firewall refuses other services there, such as a local database.
- Desktop dependencies: the bundled Electron version has one open high-severity advisory (GHSA-jr5w-w6x2-84p9), fixed only in a newer major version. It is the only exception the dependency audit allows; any other high or critical advisory blocks a merge.
- Source code: Peck's source code is not public.
9. Contact
Report security problems to security@devlin.ai. DEVLIN.AI LLC, Portland, Oregon.