# What leaves your machine

> Every network connection Atelier makes, what each one sends, and whether you can turn it off.

Every network connection Atelier makes, by feature. "Backend" means the computer running Atelier's backend: your own
computer with **Run on this computer**, or your server. Rows that cost tokens or contact third parties are in bold.

This page is about the app. What the project's websites (atelierhq.dev, these docs and the update feed) process is in
the [Datenschutzerklärung](https://atelierhq.dev/datenschutz/) (German): only what serving a page needs, no analytics,
no cookies of their own.

| Feature | What is contacted | What is sent | Can I turn it off |
|---|---|---|---|
| **Model providers** | The address of each provider you added: for example `api.anthropic.com`, `api.openai.com`, `api.mistral.ai`, `openrouter.ai`, `opencode.ai`, `api.githubcopilot.com`, `chatgpt.com`, or your own Ollama, llama.cpp or LM Studio server | The system prompt, the conversation, tool definitions, **tool results** (file contents and command output the agent read), attachments, your memory and instructions, and your key or token in a header | Not adding a hosted provider. Local servers on your own network send nothing outside it. |
| **Small-model jobs** | The small model's provider (without one, the chat's own) | Titles, compaction summaries, memory updates and answers about fetched pages: the content of those conversations or pages | Choose the small model in **Settings › Admin › Models**; memory switches in **Settings › Memory** |
| **Auto mode review** | The provider of the session's own model (the small model's for ChatGPT Chat) | Your last 10 messages, the arguments of the last 30 tool calls (plain lookups such as Read and Grep left out), and the call to judge. No tool results. | Use another permission mode |
| Provider health and model lists | Each enabled provider | A request for its model list and status. No conversation. At start, when a provider is added or edited, on **Test connection**, and when you recalculate models in **Settings › Admin › Models**. | Disable or remove the provider |
| Detecting local servers | `localhost` ports 11434 (Ollama), 8080 (llama.cpp) and 1234 (LM Studio) on the backend's own machine | A plain request; nothing leaves the machine | It runs when you open **Settings › Admin › Providers** or the first-run model step |
| **Web search** (built in) | `duckduckgo.com` (the html and lite pages), `search.brave.com`, `www.bing.com`; `en.wikipedia.org` as a floor; for news, Bing News and `news.google.com`; for programming, `api.stackexchange.com`, `hn.algolia.com` and GitHub's repository search on `api.github.com` | The query text (at most 400 characters, never a credential), and the backend's IP address | **Settings › Admin › Capabilities › Web search**, or use your own SearXNG, Brave Search API or Tavily |
| Web search with your own provider | Your SearXNG address, `api.search.brave.com`, or `api.tavily.com` | The query text, and the API key for Brave and Tavily | The same switch |
| **Reading pages** | The first three result pages of a search, and any URL the model fetches | A GET request. The model's fetches carry `User-Agent: Atelier WebFetch`; the readings of result pages carry a browser-like user agent. What comes back goes to the model. | Fetching: **Settings › Admin › Capabilities › Web fetch**. Reading result pages goes with Web search. |
| **Connectors** | The address of each HTTP or SSE connector you added; stdio connectors are programs on the backend that may contact anything themselves | The tool arguments the model chose, plus the tokens or headers you configured | Disable or remove the connector, switch it off for a chat, or set its tools to **Block** |
| **Desktop update check** | `updates.atelierhq.dev` (a Cloudflare Worker over an R2 bucket), or the server's `/updates` when you use one | A GET for `<stable or beta>/latest.yml` (`latest-mac.yml`, `latest-linux.yml`) with `User-Agent: electron-builder`, and on the public feed a `noCache` query parameter holding the current time; your IP. When an update exists, also its `.sig` file and the package. | Yes: **Settings › System › Check for updates automatically**, or `ATELIER_UPDATE_FEED=off` to remove the public feed (a copy connected to a server still asks that server). |
| Server version check | `updates.atelierhq.dev/stable/latest.yml`, or `api.github.com` with `ATELIER_UPDATES_REPO` | A GET, only when an admin opens **Settings › Admin › Server** (at most every 10 minutes) or presses **Check now** (every time) | `ATELIER_UPDATE_FEED=off` on the server, with `ATELIER_UPDATES_REPO` unset |
| Desktop updates from your server | `api.github.com` (releases of `ATELIER_UPDATES_REPO`) and the release download | Your `ATELIER_UPDATES_TOKEN` to GitHub's API | Leave the two variables unset |
| **GitHub** (Codespaces, Cloud) | `github.com`, `api.github.com`, and the GitHub tunnel used by `gh codespace ssh` | Your GitHub token; the commands and files of a codespace you work in | Do not connect GitHub in **Settings › Cloud** |
| Skill and plugin installs | `api.github.com`, `codeload.github.com` | An unauthenticated request for the repository you named | Do not install from GitHub |
| **Provider sign-ins** | ChatGPT Plan: `auth.openai.com`, `chatgpt.com`. GitHub Copilot: `github.com`, `api.github.com`. OpenRouter: `openrouter.ai`. Connectors with OAuth: the connector's own sign-in server | The sign-in exchange; for ChatGPT Plan also a usage request for the limits display | Do not sign in |
| Mistral Vibe allowance | The provider's base URL (`api.mistral.ai`): `/v1/billing/budget` and `/v1/billing/subscription` | Your Vibe key, to read how much of the plan's allowance is used, its plan name and whether pay-as-you-go is on. While an admin has a conversation on a Mistral Vibe model open or opens the context ring's popover, and when the Usage tool runs; a reading is kept for 30 seconds. | Do not add Mistral Vibe |
| ChatGPT Plan model list | `registry.npmjs.org`, besides `chatgpt.com` | A GET of the `@openai/codex` package's latest metadata, to learn the current Codex version the model list is asked with, at most every 6 hours. Nothing about you. | Do not use ChatGPT Plan |
| **ChatGPT Chat** | `chatgpt.com`, in a hidden browser window | Your messages and attachments typed into the page, plus everything the chatgpt.com page itself loads | Do not use that provider. **Remove** it from **Settings › Admin › Providers** to clear its browser session |
| Code Browser pane | The pages you open in it, and their icons | Ordinary page requests | Do not open pages in it |
| **Atelier for Chrome** | The pages the assistant opens in its own tabs of your browser | Ordinary page loads from your browser, with its cookies for those sites. What the extension reads there goes to the desktop app on this computer, then to your model as a tool result | Remove the extension, or don't add it ([below](#atelier-for-chrome)) |
| Finding servers on your network | The private /24 networks of this computer, port 7340 (first-run screen only) | `GET /api/health` | It runs only on the **Connect to a server** form |
| Your Atelier server | The server you connected the desktop app or the terminal app to | Everything you do in the app | Choose **Run on this computer** (in the terminal: **Only this computer**) |
| **Terminal app update check** | `updates.atelierhq.dev/<stable or beta>/atelier-cli.json`, at most once a day, only for a copy the installer put there; `atelier update` also asks the server's `/updates` when connected | A GET; your IP. An update then fetches its `.sig` and the package. | `ATELIER_NO_UPDATE_CHECK=1` |
| SSH hosts and codespaces | The host you connect to | The runner program (uploaded once), the commands, and the file contents the agent reads there | Do not connect |
| Commands the agent runs | Whatever they contact (`git push`, `npm install`, `curl`) | Whatever the command sends | Your permission mode and rules |
| Git actions in the Code panel | Your Git remote for **Push**; GitHub, through `gh`, for **Open pull request** | What `git push` and `gh pr create` send, with the credentials those programs already have | Do not use those buttons |
| **Issue reports and feature requests** | `reports.atelierhq.dev` (a Cloudflare Worker), or `ATELIER_REPORTS_URL` | Only when you press **Send**: the title and description, what you chose to attach (diagnostics, one conversation, pictures), Atelier's version and mode, and an optional contact. Keys, passwords and personal details are taken out first. See [Reporting issues](https://docs.atelierhq.dev/reporting-issues/). | Don't send one. An admin can turn them off in **Settings › Help & feedback**. |
| **Co-op between computers** | `coop.atelierhq.dev` (a Cloudflare Worker), or the relay set in `ATELIER_COOP_RELAY` | Only while a session has co-op on: everything the session shows its people (messages, replies, tool calls and results, the changes in the host's folder, attachments), end-to-end encrypted, so the relay can't read it. The relay sees the IP addresses, the room's id, when people connect and how many bytes pass. A guest who answers with their own model gets the session's requests on their computer, where their provider gets them. See [Co-op](https://docs.atelierhq.dev/co-op/#privacy). | Don't start or join co-op. `ATELIER_COOP_RELAY=` (empty) switches it off. On a team server, co-op needs no relay. |
| Fonts, scripts, images, analytics, automatic crash reports | none | none | |

## Model providers

The provider receives the whole request each turn, so it receives whatever is in the conversation: your words, text of files
the agent read, output of commands it ran, images and files you attached, and your standing instructions and memory.
That includes everything in a long conversation, again on each turn (providers may cache it).

- A **local** provider (Ollama, llama.cpp, LM Studio) on this computer or your network sends nothing further.
- **Anthropic** and **OpenAI** receive your API key in a header.
- **Mistral** and **Mistral Vibe** receive your key in a header, and requests go only to the base URL (`api.mistral.ai`
  unless you changed it). Atelier adds no identifying headers; the body's `prompt_cache_key` is the conversation's id in
  Atelier, so Mistral's cache can keep one conversation's requests together.
- **OpenRouter** requests carry `HTTP-Referer: https://atelierhq.dev` and `X-Title: Atelier` (also sent as `X-OpenRouter-Title`),
  naming the app.
- **ChatGPT Plan** requests carry `originator: atelier`, `User-Agent: Atelier`, your ChatGPT account id, a session id and a
  random installation id that Atelier created when you signed in.
- **GitHub Copilot** requests present themselves as the Copilot Chat extension of VS Code (`editor-version`,
  `user-agent: GitHubCopilotChat/…`), because its API refuses clients it does not know.
- Which model is used where: the chat's model answers; the **Small model** (**Settings › Admin › Models**; unset means the
  chat's own) writes titles and compaction summaries, runs memory updates and answers questions about fetched pages; Auto
  mode's reviewer is the session's own model, or the small model when the session runs on ChatGPT Chat.

## Dictation

The microphone records only while you [dictate](https://docs.atelierhq.dev/dictation/): from the press until you stop.

- **On a Mac** with its own speech recognition, the sound never leaves the Mac.
- **Otherwise** it goes from your window to your Atelier backend, which turns it into text with Atelier's own speech
  model. If an admin chose a provider instead (Mistral, OpenAI, Groq, Together, ElevenLabs, Deepgram, or a server of
  your own), the backend sends it on to that service with the provider's key.
- **The speech model** is downloaded once, the first time someone dictates on that backend: the model from Hugging
  Face (`huggingface.co`) and its engine from npm (`registry.npmjs.org`). Those requests carry nothing of yours.

Atelier stores neither the sound nor a transcript; what you send is a message like any other.

## Web search and fetch

- Built-in search sends the query to the web engines (DuckDuckGo, Brave, Bing) "as a browser would": on the desktop through
  Chromium's network stack, on a server from the server's own address. The news feeds get plain requests with a browser's
  user agent; Wikipedia, Stack Exchange, Hacker News and GitHub get plain requests that name themselves `Atelier
  (self-hosted assistant)`. The engines see the backend's address and the query, not your name or account.
- Your own SearXNG keeps queries off third parties; Brave Search API and Tavily receive the query and your key.
- Queries are refused if they look like a credential or contain one of your stored secrets. Search results are cached in memory
  for ten minutes (two when the model asks for a freshness window).
- Fetching refuses this machine, link-local and (unless an admin allows them) private network addresses. See
  [Security](https://docs.atelierhq.dev/security/#web-fetch-and-private-networks).
- With a prompt, the fetched page is given to the small model, which answers from it. The page therefore reaches that
  model's provider.

## Update checks

**The desktop app** asks for `latest.yml` (`latest-mac.yml` on macOS, `latest-linux.yml` on Linux) in the `stable` or `beta`
folder of the feed. It does so when its backend starts, after you sign in to a server, and every 5 minutes.

- The request carries your IP address, the path (which names the channel and the operating system) and electron-updater's
  headers, including `User-Agent: electron-builder`. On the public feed it also carries a `noCache` query parameter that
  holds the current time (the server's feed gets none, because it is asked with your sign-in token). Atelier adds no
  account, device id or install id, and the request does not carry the app's version. The feed's operator sees ordinary
  request logs; what it does with them is outside the app.
- When a newer version exists, the app fetches the package's `.sig` file and the package. The `.sig` request, and on macOS the
  package, go through the app's own network stack, whose user agent typically names Atelier, its version and Electron's.
- **Where it asks.** Connected to a server, first the server's own `/updates` feed (with your sign-in token, sent to that
  server only); if the server offers none (it answers 404), the public feed. On **Run on this computer**, the public feed.
- **Turning it off.** **Settings › System › Check for updates automatically** is on by default. Off, the app asks no feed
  anything by itself; **Check now** still looks. The environment variable `ATELIER_UPDATE_FEED=off` only removes the public
  feed (a copy connected to a server still asks that server), so the switch is the way to stop automatic checks. See
  [Updates](https://docs.atelierhq.dev/updates/#turning-the-check-off).

**The server** asks nothing by itself. It looks up the newest version only when an admin opens **Settings › Admin › Server**
(at most every 10 minutes, a failed lookup after one minute) or presses **Check now** (every time). See
[Updates](https://docs.atelierhq.dev/updates/).

## GitHub

- A GitHub token you save in **Settings › Cloud** (a personal access token or a device-flow sign-in) is stored encrypted and
  used only for Codespaces: listing them, starting them, and `gh codespace ssh`.
- Skill and plugin installs read public repositories with no sign-in.
- The commands an agent runs in a codespace, and the files it reads there, go to your model provider like any other tool
  result.
- A GitHub Copilot provider signs in with GitHub's device flow and exchanges the token for Copilot access; the token is
  stored encrypted.

## ChatGPT Chat

ChatGPT Chat is an experimental, desktop-only provider that types your messages into a chatgpt.com page in a hidden window
and reads the replies back. What the page loads and sends is chatgpt.com's own behavior, outside Atelier. Its conversations
are ChatGPT's **temporary chats** by default (they stay out of your ChatGPT history and memory); the provider's ⋯ menu in
**Settings › Admin › Providers** has a **Temporary chats** switch to turn that off. The window's cookies and sign-in are
kept in the app's profile folder. See [ChatGPT](https://docs.atelierhq.dev/chatgpt/).

## Atelier for Chrome

[Atelier for Chrome](https://docs.atelierhq.dev/computer-use/#web-pages-atelier-for-chrome) is a browser extension that lets the assistant work in web pages.
It works only in tabs it opened itself (the orange **Atelier** group), never in your own tabs, and closes them when the
reply ends.

- **What it reads:** the text, links, buttons and fields of a page in those tabs, and a screenshot of it, when the
  assistant asks. It doesn't read your other tabs, your history or your bookmarks.
- **Where that goes:** only to the Atelier desktop app on the same computer, through Chrome's native messaging (a local
  program the app registers; no network port). The app adds it to the conversation, so it reaches your model provider like
  any tool result.
- **What it sends itself:** nothing. The extension makes no network requests of its own, carries no analytics and loads
  no code from anywhere.
- **What it stores:** the numbers of its own tabs, in the browser's session storage, which the browser clears when it
  closes.
- **Your sign-ins:** pages in its tabs load with your browser's cookies, so the assistant can see what you see there when
  you're signed in. It never types passwords or completes a purchase, and it asks before it accepts terms or sends
  anything.

## Telemetry and crash reports

None. Atelier sends no usage analytics, tracking, crash reports or error reports to anyone. What was checked: the source and
the dependency lists of the desktop app, server, core, interface and protocol packages for analytics and error-reporting
libraries (Sentry, PostHog, Mixpanel, Amplitude, Segment, Google Analytics, Plausible, Datadog, Bugsnag, Rollbar, LogRocket,
FullStory, Hotjar, Statsig, LaunchDarkly, Umami, Matomo) and for a crash reporter, and found none. The interface loads no fonts,
scripts or images from other hosts (its Content-Security-Policy would not allow it), and the built pages contain no external
address. The runner program, which runs your commands, contains no network code of its own. The documentation site and the
product website are separate from the app.

**Copy diagnostics** (**Settings › System**, and the screen shown when a page breaks) sends nothing. It builds a plain-text
summary on your computer, puts it on your clipboard, and stops there; whether it goes anywhere is up to you when you paste
it. The summary has the version, system, how many providers and connectors are set up and their types, the last error and
the end of the app's log, with keys, tokens, addresses, file paths outside Atelier's own folders, email addresses, account and
computer names and message text taken out. See [Troubleshooting](https://docs.atelierhq.dev/troubleshooting/#reporting-a-bug).

With no chat running, the only things Atelier contacts by itself are the desktop update check above and the health and
model-list requests to the providers you added (for ChatGPT Plan, also the version lookup and the usage request in the
table; for Mistral Vibe, the allowance reading while an admin has a conversation on it open). Opening the **Connect to a
server** form scans your local network once.

## The request log

**Settings › Admin › Developer › Record provider requests** is **off by default**. While on, the backend keeps the last 100
requests it sent to providers, **in memory only**: method, address (credential-looking query parameters replaced),
request headers (any header named like auth, token, key, secret, cookie or password replaced), the request size in bytes,
the status and the time taken, and for a failed request up to 4,096 characters of the error response. Prompts and replies
are never recorded. Only admins see it. It is cleared by **Clear** and when the backend restarts. Nothing is written to disk
or sent anywhere. Connector logs in the same page show what a connector printed, with credentials masked.

## Where your data is stored

Conversations, files, memory and settings are stored on the backend: in `~/.atelier/data` on your computer, or in the
server's volume. Provider keys and tokens are encrypted; conversations are not. The full map of folders and files is in
[Data and files](https://docs.atelierhq.dev/data-and-files/).

- **Settings › Privacy › History › Keep conversations**: **Keep everything** (default), or delete conversations untouched for
  30, 90 or 365 days (pinned ones stay). The sweep runs every 24 hours while the backend is running, the first one 24 hours
  after it started, so an app that is quit within a day of starting never runs it.
- **Settings › Privacy › Your data**: **Export** (a zip of your conversations, projects, artifacts, files and memory) and
  **Delete all…** (every conversation, after typing `DELETE`).
- **Memory** (**Settings › Memory**): **Generate memory from chats** and **Search and reference chats** are on by default;
  **Include sensitive topics in memory** is off. Memory is stored per account; building it sends chat content to the small
  model's provider. See [Memory](https://docs.atelierhq.dev/memory/).

### Temporary chats

A temporary chat (the ghost button on the new-chat page, File › New Temporary Chat, ⇧⌘N / Ctrl+Shift+N) never appears in the
sidebar, lists, search or the Artifacts page, and is deleted with its files and artifacts when you leave it or close its
window; a sweep removes any left behind after a day, and the rest when the backend starts again, unless a window reopens
them. Nothing of it is saved to memory. It is still **sent to the model
provider** like any chat. **Settings › Privacy › History › Temporary chats** chooses between **Don't save (default)** and
**Start fresh**, which also keeps memory, personal instructions, your name and project context away from the model (admin
instructions and safeguards still apply). Temporary chats exist in Chat only, and are not in an export.

## Who can see what

| Who | What they can see |
|---|---|
| The model provider | Everything sent to it (first table). |
| Search engines and pages | Queries, and the backend's IP address and user agent. |
| The update feed's operator | The IP address, time and path of update requests. |
| A server's admins, in the app | The account list, aggregate usage across accounts (not per person), connector logs, and the [activity log](https://docs.atelierhq.dev/accounts/#the-activity-log) of who changed what and who signed in from which address. Not conversations, memory or files. See [Accounts](https://docs.atelierhq.dev/accounts/#what-admins-can-and-cannot-see). |
| Whoever runs the server's host | The whole data folder: conversations and files in plain form, secrets decryptable with the key in the same volume unless you set `ATELIER_SECRET_KEY` elsewhere. |
| Your other signed-in devices | Your conversations, unless you turn off [Remote control](https://docs.atelierhq.dev/remote-control/). |
| Other people with accounts | Nothing of yours, unless you invite them to a co-op session. |
| People in a co-op session with you | Everything in that session: messages, replies, tool calls and results, the changes in the session's folder, attachments, and the people's names and pictures. Nothing else of yours: no other sessions, memory, settings, terminal or files beyond the session's changes. See [Co-op](https://docs.atelierhq.dev/co-op/). |
| The co-op relay's operator | IP addresses, room ids, connection times and byte counts. Not the content: it is end-to-end encrypted. |
