What leaves your machine
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 (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) |
| 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. | 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. | 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
Section titled “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.aiunless you changed it). Atelier adds no identifying headers; the body’sprompt_cache_keyis the conversation’s id in Atelier, so Mistral’s cache can keep one conversation’s requests together. - OpenRouter requests carry
HTTP-Referer: https://atelierhq.devandX-Title: Atelier(also sent asX-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
Section titled “Dictation”The microphone records only while you dictate: 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
Section titled “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.
- 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
Section titled “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 anoCachequery 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
.sigfile and the package. The.sigrequest, 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
/updatesfeed (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=offonly 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.
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.
GitHub
Section titled “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
Section titled “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.
Atelier for Chrome
Section titled “Atelier for Chrome”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
Section titled “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.
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
Section titled “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
Section titled “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.
- 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.
Temporary chats
Section titled “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
Section titled “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 of who changed what and who signed in from which address. Not conversations, memory or files. See Accounts. |
| 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. |
| 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. |
| The co-op relay’s operator | IP addresses, room ids, connection times and byte counts. Not the content: it is end-to-end encrypted. |