Pendant

Pendant Privacy Policy

Effective date: September 27, 2026

1. Scope

This Privacy Policy explains how personal data is processed in connection with:

  • the Pendant extension for Visual Studio Code, VSCodium, and other VS Code-compatible editors (the "Extension");
  • Pendant for Desktop on macOS, Windows, and Linux ("Desktop");
  • the Pendant app for iPhone, which attaches to the Extension or Desktop on your computer when they are built with remote access (Section 5.4; release builds do not include remote access yet, and the app is not released);
  • the Pendant website at https://pendant.sh (the "Website"); and
  • the Pendant issue tracker on the Website, including its discussions area (the "Issue Tracker").

It does not cover GitHub, GitLab, Google, Discord, Open VSX, the Visual Studio Marketplace, VS Code, VSCodium, Pi, model providers, Hugging Face, pi.dev, Apple, Tailscale, your operating system, your editor, your local runtime, or other third-party services. Those products and services are governed by their own privacy policies.

2. Controller and Contact

The controller within the meaning of the EU General Data Protection Regulation ("GDPR") is:

Cem Dervis Bismarckstraße 4 69469 Weinheim Germany Email: cem@dervis.de

We are not required to appoint a data protection officer. For any question about this policy or to exercise your rights (Section 21), contact us at the address above. In this policy, "we", "us", and "our" refer to the controller.

3. Summary

The Extension, Desktop, and the iPhone app send us no telemetry, analytics, crash reports, prompts, source code, files, images, audio, transcripts, diagnostics, credentials, usage events, or application-assigned identifiers. They do not require or offer a Pendant account. The iPhone app connects only to the computers you pair it with (Section 5.4).

Packaged Desktop checks our static update server for new releases and may download them (Section 11.1). These requests create ordinary web server logs but carry no application content or telemetry.

Otherwise, the Extension and Desktop are local clients for the bundled Pi SDK and for the third-party services you configure or choose to use. Your data may remain on your device, be stored by your editor, by Desktop, or in Pi's local files, or be sent to third parties such as your configured model providers, the npm registry, Git hosts, Hugging Face, marketplaces, or your web browser. These flows are described in Sections 5 to 14.

We process personal data ourselves only when you visit the Website, use the Issue Tracker, or when Desktop checks for updates (Sections 4 and 11.1).

4. Website and Issue Tracker

4.1 Hosting and server logs

The Website and the Desktop update endpoints are hosted by Hetzner Online GmbH, Industriestraße 25, 91710 Gunzenhausen, Germany, on servers located in Germany. Hetzner processes this data on our behalf as a processor (Art. 28 GDPR).

When you visit the Website, or when Desktop checks for or downloads an update (Section 11.1), the server records standard log data: your IP address, the date and time of the request, the requested URL, the HTTP status code, the referrer URL, the response size, and the browser or client user agent. This processing is necessary to deliver the requested content and to maintain the security and stability of the service. The legal basis is our legitimate interest in operating a secure website (Art. 6(1)(f) GDPR). For Desktop update delivery, which is part of the application's functionality, Art. 6(1)(b) GDPR also applies.

Server logs are retained only as long as necessary for security, troubleshooting, and the establishment or defense of legal claims, and generally for no longer than 30 days.

4.2 Issue Tracker accounts

The Issue Tracker's database, authentication, and file storage are provided by Supabase, Inc. (United States), which processes this data on our behalf as a processor (Art. 28 GDPR). The data is stored in the Amazon Web Services region eu-central-1 in Frankfurt, Germany.

You can read public content without an account. To post, react, follow, or report content, you sign in with one of the following:

  • An external account at GitHub, Google, GitLab, or Discord. You are redirected to that provider to sign in. The provider then shares your email address, name, username, and profile picture with us, as permitted by the provider's settings. The provider processes your sign-in under its own privacy policy.
  • An email account. You provide a display name, email address, and password. The password is stored only as a cryptographic hash. We send a confirmation email to verify the address.

Supabase's authentication service stores your email address, the sign-in method, and the technical data needed to maintain your session. Your profile record holds:

  • your display name and account handle;
  • a copy of your profile picture from your sign-in provider, which we store in our own file storage so that pages showing it do not load it from the provider;
  • your GitHub username, if you signed in with GitHub, so that your name can link to your GitHub profile;
  • your account role (user or administrator);
  • whether your email address is verified, and when the account was created;
  • the website language you selected; and
  • your email notification preferences (Section 4.4).

Your display name, handle, profile picture, and GitHub username are public, so that author information can be shown next to your content. The other fields of your profile record, and your email address, are visible only to you and to us.

The legal basis is the performance of the user relationship you enter by creating an account (Art. 6(1)(b) GDPR).

4.3 Content you submit

The Issue Tracker stores the content you submit and records derived from it:

  • issues, including their title, description, status, labels, resolution, and the product version you report them for;
  • comments, including translations you provide, and their creation and edit timestamps;
  • attachments you upload (images, text, and JSON files of up to 10 MB), together with their original file names;
  • emoji reactions;
  • discussion topics and replies, reports you file about discussion content, and the topics you follow;
  • an audit log of moderation and status changes, such as an issue status change or the removal of a discussion reply, together with the account that performed the action. Only administrators can read the audit log; and
  • a record of the actions you perform and when, which is used to limit abuse (rate limiting).

Issues are public by default. You can mark an issue as private, in which case it and its comments and attachments are visible only to you and to administrators. Discussion topics and replies are always public. Public content, including your display name, handle, and profile picture shown next to it, can be read by anyone, including people who are not signed in. Do not post credentials, private keys, confidential code, or personal data of others.

The legal bases are the performance of the user relationship (Art. 6(1)(b) GDPR) and our legitimate interests in providing support, improving the Extension and Desktop, moderating the Issue Tracker, and preventing abuse (Art. 6(1)(f) GDPR).

4.4 Email notifications

Depending on your notification preferences, we send you emails about new issues, comments on issues you take part in, mentions of your handle, and activity in discussion topics you follow, such as replies and accepted answers. Administrators also receive emails about new discussion topics and reports. You can change your preferences at any time in your account settings. We do not send emails to GitHub noreply addresses.

Notification emails are sent through an email delivery service based in the EU, which processes your email address and the email content on our behalf as a processor (Art. 28 GDPR). The legal basis is the performance of the user relationship (Art. 6(1)(b) GDPR).

Our emails show the Pendant logo, which your email program loads from pendant.sh when it displays images. Our web server logs that request like any other page visit (Section 4.1).

4.5 Desktop release notifications

If you click "Notify me" next to the Desktop teaser on the Website's home page while signed in, we store your account's email address and the date you signed up. We use them only to send you a one-time email when Desktop becomes available. The legal basis is your consent (Art. 6(1)(a) GDPR). You can withdraw your consent at any time by clicking the button again, which deletes your entry immediately. Withdrawal does not affect the lawfulness of processing before it.

4.6 Browser storage and third-party content

The Website sets no cookies and uses no analytics, advertising, or tracking technology. It stores the following in your browser's local storage:

  • your sign-in session, if you are signed in;
  • the page to return to after signing in (session storage only);
  • your selected color theme, only once you choose one; and
  • your selected language.

This storage is strictly necessary to provide the functions you request (§ 25(2) no. 2 of the German Telecommunications Digital Services Data Protection Act, TDDDG). You can delete it at any time in your browser.

The home and releases pages load current release information directly from Open VSX (Eclipse Foundation AISBL, Belgium), which receives your IP address and browser information. The legal basis is our legitimate interest in displaying current release information (Art. 6(1)(f) GDPR).

Profile pictures are served from our own file storage (Section 4.2). Viewing Issue Tracker content does not cause your browser to contact sign-in providers.

4.7 Retention

Issue Tracker account data, including the copy of your profile picture, and the content you submit are retained for as long as your account exists. You can delete your own discussion replies and your Desktop notification sign-up at any time. You can delete your account yourself under Settings → Delete account, or contact us (Section 2). Administrator accounts cannot be deleted from the Website; an administrator must contact us instead. When an account is deleted, its profile, profile picture, email and notification settings, reactions, follows, reports you filed, rate-limiting records, and Desktop notification sign-up are deleted, as are uploads that were never attached to a post. Your issues, comments, discussions, discussion replies, and the attachments on them are kept so that the information stays available to others, and are attributed to a "Deleted user" with no link to your former account. Audit log entries are kept without identifying the account that performed the action. Your handle becomes available to others again.

5. Local Data Processed by the Extension and Desktop

We do not receive any of the data described in this section. The Extension reads, writes, displays, or passes the following local data as part of its normal operation, depending on your settings and use:

  • editor settings under the pendant.* configuration namespace;
  • extension state stored by the editor, such as remembered session status, cached command metadata, and your package README image choice (Section 9.2);
  • provider credentials stored in Pi's local auth.json when you configure them through supported flows;
  • environment variables visible to the editor's extension host, and additional variables you set in pendant.piEnvironment;
  • your Pi agent directory, including Pi settings, models, credentials, sessions, and other Pi-managed files. It defaults to ~/.pi/agent and can be changed with the pendant.agentDir setting or the PI_CODING_AGENT_DIR environment variable;
  • chat sessions, transcripts, message history, session names, fork metadata, and session statistics exposed by the local Pi SDK;
  • prompts and messages you type, and your local prompt history;
  • selected editor text, active file metadata, cursor position, visible range, open tabs, diagnostics, Git branch and status counts, files or folders you mention, pasted images, and other workspace context when enabled or attached;
  • previews of files and images in your workspace;
  • dictation model files downloaded to the Extension's model cache, microphone audio processed on your device, and the resulting transcripts;
  • local diagnostic log files (Section 5.2);
  • in a build that includes Remote access, when you turn it on, an identity key, the list of phones you paired, and the list of VS Code windows that are listening, with each window's port, workspace name, and process ID (Section 5.4); and
  • output from an optional custom notification hook (Section 12).

5.1 Desktop local access and storage

Desktop is a trusted local application. Its renderer has Node.js and full local-user access to your machine. Desktop, its renderer code and dependencies, Pi, user or project packages and extensions, skills, prompts, themes, language servers, terminals, external-editor commands, and other integrations may read, write, display, store, execute, or process any local file or directory they select. This includes files outside an opened workspace and files commonly treated as sensitive, such as authentication files, environment files, credentials, private keys, certificates, keystores, and cloud-provider configuration.

Depending on your settings and actions, Desktop's local state may include:

  • Desktop settings and window, tab, editor, terminal, recent-workspace, and update state;
  • Pi agent directories, settings, packages, extensions, credentials, sessions, transcripts, and runtime state;
  • workspace file and Git metadata, search and preview results, context, attachments, images, prompts, messages, command or tool output, and results from external integrations;
  • saved changed-file activity summaries, recorded tool edit patches, workspace Trash journals, and hashed workspace identifiers;
  • dictation models, audio processed on your device, and the resulting transcripts; and
  • in a build that includes Remote access, when you turn it on, an identity key and the list of phones you paired (Section 5.4).

Undo recorded edits uses the complete text edit patches already recorded in tool activity and checks the current file content before writing. It does not keep separate file snapshots, redo history, or a session rollback log. Paths that are unsupported or have changed are skipped.

Desktop applies ordinary existence, type, encoding, size, and request-validity checks where a feature requires them, but it does not exclude a file because of its name or sensitivity. Opening a workspace does not create a security boundary around that folder.

Desktop has no telemetry or remote crash reporting, and its diagnostics remain local and size-limited. A support bundle is created only when you export one. It is sanitized to exclude secrets, credentials, prompts, transcripts, raw workspace content, arbitrary process output, and other unbounded private data. We do not receive the bundle; review it before you share it. A session report (Section 5.3) is likewise created only when you export one.

5.2 Local diagnostic logging

Diagnostic logging is enabled by default and can be disabled with pendant.diagnostics.enabled. The Extension records what it, its local Pi SDK worker process, and its chat panels were doing, in timestamped log files in the logs folder of the Extension's internal storage, one line per event. This is the only diagnostic recording the Extension offers.

A line records which part of the Extension was reached and the outcome, and, for an operation that ended early, which of its stages it reached. Examples are starting, replacing, reconnecting, or recovering the local Pi SDK worker; opening, prewarming, switching, or closing a Pi session; loading models, commands, or session history; sending, stopping, or loading a conversation; a context-compaction pass; a message passing between a chat panel and the extension host; Pendant running one of its own editor commands; creating a session worktree; or, on Windows, setting or checking the owner-only permissions Pendant applies to its own folders and files. A line may also contain:

  • counts, byte sizes, character counts, durations, and delays, such as how many messages a session holds, how large its file is, how long each phase of opening it took, how many characters a response streamed, or how long a chat panel waited to render;
  • memory and machine facts: the heap, resident, and external memory of the SDK worker and the extension host, the V8 heap limit, garbage-collection pauses, how long the worker's event loop was blocked, and the machine's processor core count and total memory;
  • identifiers: short Pi session IDs, local Pi SDK command names, chat-panel message types, VS Code command IDs, extension and error codes, exit codes, and signal names;
  • how many Pi extensions loaded or failed to load;
  • where a session's project configuration came from, recorded as yes-or-no facts and counts rather than locations: whether the session's folder contains a .pi/settings.json, whether the project is trusted, how many loaded skills came from the project, whether a custom session directory was configured in the project or global settings file, whether it was written as a relative path, and whether it and the session's folder are the folder the editor opened. None of these names a folder;
  • how creating a session worktree went, recorded as counts, durations, and yes-or-no facts rather than names: how long each step and the Git commands took, which Git command was slowest, how many files the checkout wrote, whether Git would run a post-checkout hook, whether the repository's top-level .gitattributes uses Git LFS, how many files and folders .worktreeinclude copied, and, for a creation that failed, its error code and the step it reached. None of these names a folder, worktree, or branch;
  • when a request to a model provider fails, what kind of failure it was rather than what the provider said: a category such as connection, certificate, timeout, authentication, or rate limit, the HTTP status code, and the Pi API type the model uses. For a failure on the network below the request, the network or certificate error code, whether the request used HTTP or HTTPS, whether it went to this computer, a private network address, a public address, or a host name, whether a proxy was configured and the status code a proxy refused it with, and how many system and extra root certificates Pendant trusts. None of these names a provider, host, address, port, or proxy, or contains the provider's error message;
  • the name and message of an error Pendant itself encountered, which can name a file or folder on your machine; and
  • when the Pi SDK worker process ends abnormally, the fatal reason it wrote to its error output (for example, an out-of-memory report), limited to 8,192 characters.

At the start of each log file, the Extension also records the Pendant version, the host application's name and version, the operating system platform and architecture, the Node.js and Electron versions, the processor core count, total memory, and whether the workspace is a remote connection.

No line contains the content of your conversations: not your prompts, the model's replies or reasoning, tool arguments, tool output, shell command output, file contents, credentials, or environment variable values.

Pendant never transmits the diagnostic log. Log files persist across editor sessions. Each file is limited to 10 MiB, and only the ten most recently written files are kept. Inactive logs are deleted after seven days by default, configurable with pendant.diagnostics.retentionDays (1–365 days). Cleanup runs at startup, during rotation, and when retention changes. The active log is retained until it is closed or rotated. A new file is created on the first diagnostic event of each extension activation, whenever the current file reaches its size limit, and on the first entry after the local date changes. Entries use local time to the second; the filename carries the date. Disabling the setting stops new entries but does not immediately delete saved files; the retention limits still apply. Desktop also saves its diagnostic entries in the logs folder of its application-data directory, using the same setting and retention limits. Its diagnostics drawer keeps a bounded in-memory buffer.

The Pendant: Show Diagnostics Log command opens the current or most recent log file in the editor. Open log file, directly below Settings in the Pi button menu, reveals the current or most recent saved log in the file explorer with the file selected. In remote workspaces without local file-manager access, it opens the log in the editor instead. Logging is controlled only through pendant.diagnostics.enabled in settings. These actions never enable logging or create a file. You can delete saved logs from that folder or share them yourself. Review them first: they can contain file and folder paths, session IDs, and error messages.

5.3 Session reports

Export report… in a session's menu saves a zip file for investigating a problem in that session. It is created only when you choose it, it is saved where you choose, and we never receive it. Before it is created, a dialog lists what it keeps and what it removes.

The zip contains a copy of the session file in which every message, reply, reasoning text, tool input and output, diff, file content, image, session title, label, and extension-written value is replaced by placeholder text of the same length and layout. File and folder names are replaced by stable placeholder names such as p1/p2, response IDs by placeholders such as r1, and API keys, tokens, and email addresses are masked. The copy keeps the order and branching of entries, their timestamps, tool and model names, token usage, the session ID, and error messages.

In the Extension, while diagnostic logging is enabled, the zip also contains the diagnostic log files whose time span overlaps the session, with the same placeholders and masking. In Desktop, it contains the sanitized support bundle and, while logging is enabled, the window's recent diagnostic entries and saved logs overlapping the session, treated the same way. A report.json file lists the versions and what was included. Review the zip before sharing it.

5.4 Remote access (optional, off by default)

This section applies only to builds of Pendant that include remote access. Release builds of the Extension and Desktop do not include it yet: they have no Remote access settings or section, never listen for a phone, and store none of the data described here, and the iPhone app is not released.

When you turn on Remote access, Pendant accepts connections from phones you have paired by scanning a QR code. It stores an identity key and the list of paired phones, with each phone's name, model, operating system and public key and when it was paired and last connected. In Pendant for Desktop, the application listens on one TCP port and keeps these in its private application data directory on your computer. In Pendant for VS Code, each VS Code window in which Pendant is running listens on a TCP port of its own, and all local windows of the same VS Code installation and profile share one identity key, one list of paired phones and a small list of the windows that are listening, with each window's port, workspace name and process ID (identity.json, devices.json and listeners.json in the extension's global storage), so pairing once covers every window of that profile; a window in another VS Code profile keeps its own and is paired separately. On macOS and Linux these files are readable only by your user account; on Windows they take the permissions of the folder that holds them. VS Code Settings Sync does not carry them, and the pendant.remote.enabled and pendant.remote.port settings apply only to the computer you set them on, so Settings Sync does not turn Remote access on elsewhere. Under VS Code Remote (SSH, WSL or a container) the files are kept on the remote machine, so pairing there is separate from pairing on your own computer.

Traffic between a paired phone and your computer is encrypted end to end with keys held only by those two devices, and it never passes through a Pendant server or a relay of ours; a VPN you use to reach your computer, such as Tailscale, may carry the encrypted traffic. Until the encrypted handshake completes, neither device sends anything about itself, and nothing about your sessions is sent: a device that reaches the port sees only opaque handshake bytes, with no banner and no version. Turning Remote access off closes the port, and revoking a phone closes its connections and refuses it afterwards, in every window.

In Desktop, each window's diagnostic entries, which are kept in memory and persisted locally while diagnostic logging is enabled, record by name when a phone pairs, connects or disconnects, or when serving it fails, and the network address of a connection whose handshake failed or ran late. A session report you export (Section 5.3) includes these entries, and its redaction does not remove phone names or network addresses; review the report before you share it. Pendant for VS Code does not record them.

The iPhone app connects directly to the computers you paired it with and to nothing else. It has no account, no analytics, and no server of its own. It stores its identity key in the iOS Keychain, marked this-device-only so it is never restored onto another device, even from a backup. Inside its own app container it keeps the list of computers you paired with (each computer's name, platform, Pendant version, public key, addresses and port, when the phone last connected to it and, for Pendant for VS Code, the port and workspace name of each window that was listening), a cached copy of the transcript interface a computer served (Pendant's own interface code, none of your sessions), and a count of failed connection attempts to each window, kept with the computer's public key and port, the phone's own network address and the address it dialed, so that it stops retrying before a computer starts refusing it. These are included in your iPhone's backups like other app data. The attempt counts do not expire: when a connection to a window succeeds, the computer reports how many failed attempts it still holds against the phone, and the phone keeps only that figure for the window. Forgetting a computer removes that computer's record from the phone, but its attempt counts, and with them the computer's public key, the window's port and the addresses the phone dialed, are kept, because the computer may still be counting the same attempts; they are replaced by the computer's figure when a later connection to that window succeeds, and removed with the app. The iOS app shows local notifications on the phone itself when it is not in the foreground; these name only a session title and a computer name, never the text of a message, a transcript, or anything your computer sent. A phone set to hide notification previews shows no notification's title or text, except a send-failure notification, which shows its title and a fixed sentence asking you to open Pendant.

Remote access is not a remote workspace. Your sessions, tools, files and model requests keep running on the computer, exactly as they do without a phone. A paired phone sees your session list and the transcript of the session it opens, with its statistics and changed files, and can do what you could at the keyboard in that session: send prompts, including a prompt that starts with /bash, which runs the rest as a shell command on the computer under your user account; stop a run or a tool call; and answer an extension's questions.

6. Prompts, Files, Images, and Workspace Context

The Extension and Desktop pass your chat input and the context you select to the local Pi SDK. Pi may then send that data to the model provider, model endpoint, tool, package, or service you have configured.

Depending on your settings and actions, the data passed to Pi may include:

  • your prompt text and prior conversation context;
  • selected text from the active editor;
  • active file metadata and file paths;
  • diagnostic messages from the editor;
  • Git status summaries;
  • files or folders you reference;
  • pasted image attachments;
  • command output, tool output, diffs, and generated edits; and
  • system prompts, appended prompts, skills, prompt templates, and extensions configured for Pi.

Some optional features also send content to your configured model provider: generating a commit message sends the staged changes, and automatic session naming and prompt suggestions send conversation text.

On Desktop, renderer code, Pi, packages, extensions, commands, language servers, external editors, and integrations can select and process any local file, whether or not it is inside the opened workspace. Pendant does not filter out credentials or sensitive files before passing user-selected or integration-selected data to a local component.

We do not route this data through our servers. Any onward transfer is determined by the local Pi SDK, the selected model and provider, the enabled tools, and your provider configuration.

Do not send confidential, regulated, personal, customer, secret, or proprietary data to a model provider unless you have reviewed and accepted that provider's terms and privacy practices.

7. Model Providers and Provider Credentials

The Extension and Desktop let the local Pi SDK use provider credentials from local configuration, environment variables, Pi's auth.json, and Pi's provider sign-in flows, which open the provider's login page in your browser. Supported environment variables include keys for providers such as OpenAI, Azure OpenAI, Anthropic, Google Gemini, OpenRouter, DeepSeek, Groq, Mistral, xAI, Z.ai, Cerebras, Vercel AI Gateway, OpenCode, Hugging Face, Kimi, MiniMax, and others supported by Pi.

These credentials are never sent to us. They are passed to the local Pi SDK, or to the relevant provider's endpoints when you use that provider or a related feature.

Provider credentials are not stored in VS Code SecretStorage. On startup, the Extension attempts to delete legacy pendant.apiKey.* SecretStorage entries from earlier versions without reading their values. If an entry cannot be removed, it is left in place.

Your provider governs its own processing of your requests. We do not control provider logging, retention, model training, abuse monitoring, billing, security, data location, or account policies.

8. Subscription Usage and Credit Checks

The Extension can display subscription usage limits or credit balances for supported providers. These requests go directly to the provider concerned and use the credentials Pi holds for that provider. They are not a telemetry channel, and we do not receive their results.

When enabled and relevant to the active provider, the Extension may contact:

  • ChatGPT/Codex at https://chatgpt.com/backend-api/wham/usage, and, when banked limit resets are available, at https://chatgpt.com/backend-api/wham/rate-limit-reset-credits, with your access token and, where provided by Pi, an account identifier;
  • when you explicitly confirm using a banked Codex reset, https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume, with the same credentials and a newly generated request identifier;
  • Kimi Coding at https://api.kimi.com/coding/v1/usages, with your Kimi access token;
  • MiniMax at https://api.minimax.io/v1/token_plan/remains (or the corresponding api.minimaxi.com endpoint for MiniMax China), with your MiniMax API key; and
  • OpenRouter at https://openrouter.ai/api/v1/credits or https://openrouter.ai/api/v1/auth/key, with your OpenRouter API key.

If you configure a custom base URL for ChatGPT or Kimi (including through the KIMI_CODE_BASE_URL environment variable), these requests go to that URL instead. The results are displayed in the editor and are not stored.

These checks do not run in offline mode. You can also disable them with pendant.subscriptionUsageEnabled and pendant.openrouter.showCredits.

9. Pi Packages

To report whether the Pi packages configured in your Pi settings have newer versions, Pendant asks the local Pi SDK package manager to check each configured package. This may involve operations equivalent to:

  • npm view <package> version, which contacts the npm registry; and
  • git ls-remote for a package installed from a Git source, which contacts the Git host of that package's remote.

Installing or updating packages contacts the same registries or Git hosts. We operate neither service and receive none of these requests. Package update checks, installation, and catalog requests are disabled in offline mode.

9.1 Package catalog

Opening or refreshing the package catalog in the Extension or Desktop may contact registry.npmjs.org to search the catalog and read package metadata. These requests carry no Pendant identifier or telemetry and are not made in offline mode. Package links open in your web browser.

9.2 Package README images

Package READMEs may reference images on arbitrary third-party servers. Loading such an image reveals your IP address to that server. The Extension and Desktop therefore let you choose once, for all packages, whether to Ask before loading README images, always Allow them, or Block them. Ask is the default. Images are downloaded only when allowed and never in offline mode.

10. Dictation and Whisper Model Downloads

Dictation is processed entirely on your device. When you use the microphone button, the Extension or Desktop uses native helpers and whisper.cpp model files to transcribe audio locally. We do not receive microphone audio or transcripts.

The first time you use a dictation model, the Extension or Desktop downloads the model file from:

https://huggingface.co/ggerganov/whisper.cpp/resolve/main/<model-file>

That request goes to Hugging Face, which may receive ordinary network information such as your IP address, request headers, timing, and the requested file path, and processes it under its own privacy policy. Model downloads are not made in offline mode.

Eight models are available: tiny, tiny-q5_1, tiny.en, tiny.en-q5_1, base, base-q5_1, base.en, and base.en-q5_1. The .en variants are English-only, and the q5_1 variants are smaller, quantized versions. The default is base. Only the selected model is downloaded. You can delete downloaded models from the Extension's info menu.

The relevant settings are pendant.voice.enabled, pendant.voice.model, pendant.voice.modelPath, pendant.voice.language, and pendant.voice.inputDevice. Your operating system may also ask for microphone permission for the editor or the native helper.

11. Pi SDK Distribution

Pendant includes one pinned version of the Pi SDK in its Extension and Desktop packages. You do not install Pi or Node.js separately, and Pendant does not download Pi at runtime. Pi SDK updates arrive only through Pendant releases. The bundled SDK uses the local Pi configuration, agent directory, credentials, models, sessions, extensions, skills, prompts, and themes described in this policy.

11.1 Desktop update checks and downloads

Packaged Desktop checks for updates at:

  • https://pendant.sh/desktop/releases/stable/<platform>-<architecture>.json; and
  • a file under https://pendant.sh/desktop/releases/stable/ when a signed update is available.

With the default Automatic policy, Desktop checks once after a successful startup and then every six hours while it is running, and automatically downloads and stages a newer verified release. Notify only performs the same checks but waits for you to start the download. Never prevents both automatic and manual checks from reaching the network. Development builds do not check for updates.

Each request creates the server log entry described in Section 4.1. The requested path identifies your operating system platform and processor architecture, and a download path also identifies the requested release file. Desktop identifies itself with the user agent Pendant-Desktop-Updater. The server may therefore receive your IP address, the request time, the requested URL, the response status and size, and that user agent. The request contains no prompts, source code, local file names, workspace information, credentials, account data, cookies, application-assigned identifiers, diagnostics, crash reports, or telemetry.

Desktop refuses redirects, verifies the signed update metadata and the release file's SHA-256 hash and signature, and keeps the previous verified version for rollback. We use the resulting server logs only for the purposes described in Section 4.1, not to build profiles, count installations, or measure feature usage.

12. Custom Notification Hooks

If you configure pendant.notifications.customHook, the Extension runs the command you provide, through your system shell, for the events selected in pendant.notifications.customHookEvents (by default, when Pi requests your input). The hook receives the event, title, message, and session path as environment variables and as a JSON object on standard input. It runs with your local user permissions, is stopped after 10 seconds, and may contact third-party services depending on what it does.

The Extension records the command, event, session path, standard output, standard error, exit status, errors, and timeout status in the local Pendant Hooks output channel, which you can open with Pendant: Show Hook Log. This output remains in the editor session unless you copy or share it. It can contain local paths and hook output, so review it before sharing. We do not receive hook output.

13. Other Network Connections

The Extension and Desktop may also make the following connections. None of them sends data to us.

  • Pi changelog preview (Extension). When you open the changelog link in a Pi update notice, the Extension loads the page from https://pi.dev and shows it in an editor panel. The panel may load images referenced by that page from other servers.
  • Git remotes. Actions you start, such as fetching, pulling, or pushing in Desktop's Git panel, contact the Git host of your repository.
  • Language servers (Desktop). Installing a language server when you choose Install runs the corresponding package manager (such as npm, Homebrew, Go, rustup, pipx, or RubyGems), which downloads it from that package source.
  • Spell checking (Desktop). On some platforms, particularly Linux, the spell checker built into Electron may download dictionary files from Google's servers.
  • Links. Links to Pendant, pi.dev, provider websites, package pages, and links that Pi extensions ask to open are opened in your web browser.

14. Marketplace, Editor, Operating System, and Browser Data

Installing, updating, searching for, rating, or using an extension through the Visual Studio Marketplace, Open VSX, VS Code, VSCodium, another editor, an operating system, a web browser, or a package manager may involve data collection by those third parties, such as account data, installation metadata, editor telemetry, crash reports, update checks, IP addresses, device information, browsing history, and download logs. This processing is outside our control. Review the privacy settings and policies of your editor, marketplace, operating system, browser, network provider, and package managers.

If you install the iPhone app through Apple's App Store or TestFlight, Apple's terms and privacy policy apply to that distribution. If you reach your computer from the iPhone through Tailscale or another VPN you choose, that service's terms and privacy policy apply to it; Tailscale's relays may carry the connection, which stays encrypted end to end between the phone and the computer (Section 5.4).

15. No Sale, Advertising, or Profiling

We do not sell personal data, share it for cross-context behavioral advertising, show targeted ads, create user profiles, or make decisions based solely on automated processing, including profiling, within the meaning of Art. 22 GDPR. The server logs described in Sections 4.1 and 11.1 are not used for any of these purposes.

Third-party providers, marketplaces, editors, browsers, websites, and services may have their own advertising, analytics, personalization, profiling, or retention practices, which we do not control.

16. Retention of Local Data

We store no Extension or Desktop application content on our servers. Retention of server logs and Issue Tracker data is described in Sections 4.1 and 4.7.

Local data is retained according to your device, editor, workspace, file system, Pi-managed files, and settings. For example:

  • session history remains in the Pi agent directory until you or Pi delete it;
  • editor settings remain until you change or remove them;
  • provider credentials in auth.json remain until you or Pi remove them;
  • Desktop settings, window state, changed-file activity summaries, Trash journals, and other local state remain in Desktop's application-data directories until you, Desktop's own retention limits, or an uninstall action delete them;
  • data from a review feature in earlier versions of Desktop remains on disk; current versions do not use, migrate, or delete it;
  • downloaded dictation models remain until you delete them;
  • diagnostic logs remain until you delete them or the ten-file, 10 MiB-per-file limit or configurable age retention removes them;
  • hook output remains in the editor's output channel for the editor session;
  • in a build that includes remote access, its identity key and the list of paired phones remain after you turn Remote access off, until you delete them, and a phone stays paired until you revoke it; a VS Code window leaves the list of listening windows when it stops listening, and if it ends without doing so, for example in a crash, its entry stays until another window running Pendant next updates the list;
  • the iPhone app's list of computers remains until you forget a computer or remove the app, its cached transcript interface until a computer serves a different one or you remove the app, and its connection attempt counts, with the computer's public key and the addresses the phone dialed, until a later successful connection to that window replaces them or you remove the app; and
  • data held by providers is retained according to their policies.

Uninstalling the Extension or Desktop may not delete local settings, Pi files, session history, credentials, models, logs, editor state, or Desktop application-data directories. You may need to delete them separately.

17. Security

The Extension relies on the security features of your editor, operating system, and file system to protect local data. File previews resolve paths relative to the active session and workspace, while explicit links and attachments can refer to files outside the workspace.

Desktop is deliberately unrestricted trusted local software. Its renderer, Pi SDK sessions, packages, extensions, commands, terminals, language servers, external editors, and integrations run with your local user permissions and can read, modify, execute, or transmit local data according to what you install, configure, or direct. Selecting a workspace organizes your work; it is not a security boundary.

For the Website and Issue Tracker, we use encrypted connections (HTTPS), access controls, and the security measures of our processors.

No system is completely secure. You are responsible for securing your device, editor profile, workspace, shell environment, provider credentials, agent directory, backups, exported files, and third-party accounts. Take care when using coding-agent tools, packages, extensions, commands, and integrations with sensitive data: depending on your settings, instructions, and the software you run, they can read context, run commands, modify files, and transmit data to model providers or other services.

18. Your Choices and Controls

pendant.offline stops the network operations that Pendant itself initiates, including package checks and catalog requests, README images, usage and credit checks, and dictation model downloads, and is also passed to the Pi SDK. The network behavior of providers, extensions, packages, and tools you configure depends on that software.

Desktop does not offer a restricted execution mode or per-workspace command approval. You control it by choosing which workspaces, runtimes, packages, extensions, commands, providers, language servers, editors, and integrations to open, install, configure, or run. Its update setting offers Automatic, Notify only, and Never (Section 11.1).

Privacy-relevant Extension settings include:

  • pendant.offline
  • pendant.context.autoAttach, pendant.context.includeEditor, pendant.context.includeSelection, pendant.context.includeDiagnostics, and pendant.context.includeGit
  • pendant.toolPreset, pendant.customTools, and pendant.disableContextFiles
  • pendant.agentDir and pendant.piEnvironment
  • pendant.messageHistory.enabled
  • pendant.autoGenerateSessionNames and pendant.chat.promptSuggestionsEnabled
  • pendant.subscriptionUsageEnabled and pendant.openrouter.showCredits
  • pendant.diagnostics.enabled
  • pendant.voice.enabled, pendant.voice.model, pendant.voice.modelPath, pendant.voice.language, and pendant.voice.inputDevice
  • pendant.notifications.customHook and pendant.notifications.customHookEvents
  • pendant.remote.enabled and pendant.remote.port, in a build that includes remote access (Section 5.4)

You can also avoid typing or attaching sensitive data; remove provider credentials from Pi's auth.json or other local configuration; change or delete the contents of your Pi agent directory; delete downloaded dictation models and saved diagnostic logs; configure privacy settings directly with your providers; use the privacy controls of your editor, marketplace, browser, and operating system; and uninstall the Extension or Desktop.

19. International Data Transfers

The Website, the Desktop update service, and the Issue Tracker's data are hosted in Germany. Supabase, Inc. is based in the United States. Where Supabase or its sub-processors access personal data from outside the EU/EEA, the transfer is safeguarded by the EU Standard Contractual Clauses included in Supabase's data processing agreement. Hetzner, our email delivery service, and the Eclipse Foundation (Open VSX) are based in the EU.

Sign-in providers such as GitHub, Google, GitLab, and Discord, which you contact when you choose to sign in with them (Section 4.2), may process data in the United States or other third countries. Where such a provider is certified under the EU–U.S. Data Privacy Framework, transfers to it are covered by the European Commission's adequacy decision of July 10, 2023.

Third-party services you use with the Extension or Desktop, such as model providers, the npm registry, Git hosts, pi.dev, Hugging Face, marketplaces, and editors, may process data in other countries under their own policies.

20. Children

The Extension, Desktop, and Issue Tracker are developer tools and are not directed at children under 16. We do not knowingly process personal data of children under 16. If you believe we have done so, contact us and we will delete it.

21. Your Rights

Under the GDPR, you have the right to:

  • obtain access to the personal data we hold about you (Art. 15 GDPR);
  • have inaccurate data corrected (Art. 16 GDPR);
  • have your data erased (Art. 17 GDPR);
  • have processing restricted (Art. 18 GDPR);
  • receive your data in a structured, machine-readable format (Art. 20 GDPR); and
  • withdraw your consent at any time with effect for the future (Art. 7(3) GDPR).

Right to object: Where we process your data on the basis of legitimate interests (Art. 6(1)(f) GDPR), you have the right to object to that processing at any time on grounds relating to your particular situation (Art. 21 GDPR). We will then stop processing the data unless we can demonstrate compelling legitimate grounds that override your interests, rights, and freedoms, or the processing serves the establishment, exercise, or defense of legal claims.

To exercise these rights, contact us at the address in Section 2. Because the Extension and Desktop send us no application content or telemetry, we normally hold no such data about you. We may hold Website and update server logs and Issue Tracker data. To help us find your data, please state the account, approximate time, or other details concerned.

You also have the right to lodge a complaint with a data protection supervisory authority (Art. 77 GDPR), in particular in the EU member state of your habitual residence or place of work, or where the alleged infringement took place. The authority responsible for us is the State Commissioner for Data Protection and Freedom of Information Baden-Württemberg (Der Landesbeauftragte für den Datenschutz und die Informationsfreiheit Baden-Württemberg), Lautenschlagerstraße 20, 70173 Stuttgart, Germany.

For local application data, use the controls of your device, editor, Desktop, file system, and Pi. For data held by third parties, contact the relevant third party, such as your model provider, marketplace, editor vendor, browser vendor, sign-in provider, Hugging Face, or pi.dev.

Providing personal data is neither legally nor contractually required. You can use the Extension and Desktop, and read the Website, without providing any personal data to us. An Issue Tracker account requires the data described in Section 4.2.

22. Changes to This Policy

We may update this policy to reflect changes to Pendant, the Website, the Issue Tracker, or applicable law. The current version is published at https://pendant.sh/privacy/ and distributed with the Extension and Desktop, and the effective date at the top shows when it was last changed. If we introduce any new collection of data, telemetry, analytics, accounts, hosted services, or server-side processing for the Extension, Desktop, Website, or Issue Tracker, we will update this policy before or when that change takes effect.