What stays on your computer
By default, everything about a project is on your computer: its files, the agent, the commands it runs, the preview, the checks, run history and memory.
Two things leave your computer because they must:
- Your requests and the code the agent reads go to the model provider you chose (OpenAI, Anthropic, or another), so the model can answer. That provider's terms apply. With a local model, they stay on your computer.
- A cloud project runs in Graspable cloud (sandboxes at our provider, E2B), or in your own cloud if you set one up. See Cloud Agents.
- Fast mode sends the step it speeds up (the file being edited, the lines a search reads, or the command output) to Graspable and our provider for that step, Morph. Graspable does not store it. Fast mode is off unless you turn it on. See Fast mode.
- Voice sends what you say to ElevenLabs while you use the microphone beside the prompt: directly with your own ElevenLabs key, or through Graspable on Credits. Graspable keeps no recording and no text of it, only how many seconds were turned into text that day. See Voice.
- The app asks graspable.dev for the current agent instructions. The texts Graspable writes for the agent can be updated without an app update. The request carries nothing about you or your project, and the app works offline with the texts it last saw.
Graspable itself receives only what this page lists.
Run summaries
After each finished run, the app sends one anonymized summary to Graspable. This is on by default, and it is sent only while you are signed in to a Graspable account.
The summary contains:
- the engine, model and template,
- the version of Graspable's own instructions to the agent, and the text of those instructions (written by Graspable, the same for everyone),
- the outcome and duration,
- counts: events, tool calls, approvals, denials, repairs, memory items recalled and saved,
- whether the build passed first time,
- tokens and cost,
- System One decisions, as numbers and labels,
- the app version,
- if the team is testing a variant of the agent's instructions, which variant your run got. You can see that variant in the Context list of the run.
The summary is tied to a run key made by scrambling your account ID with the run ID, not to your name.
Error reports
When something breaks in Graspable itself, the app sends a short error report so it can be fixed: an error in the app's window, in the agent on your computer, or a run that ended with an error.
A report holds:
- the kind of error and its message,
- for errors in the app or the agent, where in Graspable's own code it happened,
- the version of Graspable and your system (macOS, Windows or Linux).
Before a report leaves your computer, the path of your home folder, email addresses and anything that looks like a key or a token are taken out of it, and the message is cut to a few hundred characters. Graspable's server does the same again and keeps nothing about who sent it: a report is not tied to your account.
Upstream HTTP error bodies are omitted from reports, including any balance or request text they contain. The HTTP status is kept, including when a provider omits the HTTP prefix. Multiline response bodies are removed from stack reports too. Sentry is told not to infer an IP address for a desktop report.
A report never contains your requests, your code, or what the agent did.
Usage of the app
The app counts how it is used, so we can see what people do with it and what they never find. It sends these events, and only these:
- the app was opened, and which screen is open (the Projects page, a project, Settings), without the project's name or id,
- you signed in to your Graspable account, added an AI account (which provider), or started signing in to an agent,
- a project was created and from which template; a premium template was chosen without the plan for it; a project was made from a published app; a capture was kept or chosen as a project's picture (never the picture itself),
- a run started (which agent, which template, on your computer or in the cloud, how many connected services) and how it ended, in numbers: how long it took, how many steps, repairs, approvals and tokens, its cost at your AI provider, whether it built first time,
- a scene was shipped (a run that ended with a project that builds and loads), and whether it was your first,
- you answered an approval, undid a run, restored a version, or rated a message 👍 or 👎,
- the preview was opened, the project was shared to a headset (Wi-Fi or USB), runs were compared, a world was added,
- voice was used, and how (a spoken request, a conversation, talking in the headset, or a message read aloud), never what was said,
- an app was published, as public or private; a project was moved to the cloud or back; a project was linked to GitHub,
- a connected service (which one), a plugin or a skill was added,
- the page for buying a plan or Credits was opened.
A project appears in these events as a short code made from its id, so shipped scenes can be counted per project. The code cannot be turned back into the project's name.
Each event carries the app's version and your system. Once you are signed in to your Graspable account it also carries your account id, never your email, so a download can be followed to a first project.
The app does not record what is on the screen: no clicks, no typed text, no session recordings. A request, your code, a file name or a project's name cannot leave this way.
These events go to PostHog, the analytics service Graspable uses, which stores them in the United States.
Graspable's own server also records in PostHog what it does for your account: that a plan started, changed or ended, that Credits were bought or spent and on what, that a Cloud Agent started, and how many times a published app was visited. These carry your account id and amounts, never a card or an email.
The same counts of runs, added up over everyone, make the public model leaderboard: how often each model finishes, what a run costs and how long it takes. A model is shown only after five runs by at least three people, so no person's use can be read from it.
Emails. A new account gets one email a day for its first week, from Michal, about getting started. The welcome arrives first; the following emails are scheduled for 10:00 in your time zone, including across daylight-saving changes. If your time zone is unavailable, they use the time of day you signed up. Every one has a link that stops them at once, and none is sent after that. Emails about your own account, such as a sign-in link, are separate and always sent. The first-week emails record whether each was delivered and opened, and whether a link in it was followed, so we can tell which of them are worth sending; account emails are not tracked this way.
What you do in Community is kept with your account, because it is what the feature is: which apps you liked, whom you follow, and your collections. Likes are shown as a count, never as a list of names; a public collection and your follower count are shown on your handle's page.
Use from grasp, MCP and the API
When Graspable is used from outside the app, by you in a terminal or by another AI agent, it counts that use so we can see how agents work with it:
- a
graspcommand (its name only, such asrunorpublish), an MCP tool call (the tool's name), or a call to the local API made with an access token (its route, such asPOST /projects/:id/preview), - the client that made it (an MCP client's name, such as Claude Code or Cursor, or the program's name for an API call),
- which agent started
grasp, when one can be told from its environment (Claude Code, Codex, Cursor, a terminal, a script, CI), - whether it worked and how long it took,
- the version, your system, and an installation category inferred from the program's location (Homebrew, the install script, the app, development or unknown). The location itself is never sent.
They carry a random id made on your computer, not your account, and never the arguments: no requests, paths, file names or output. To turn this off, run grasp telemetry off, untick the switch in the app (the two share it), or set DO_NOT_TRACK=1 or GRASPABLE_TELEMETRY=0.
Welcome questions
A little while after the app starts, it asks four optional questions in a dialog: how you heard about Graspable, what you want to make, what describes you, and which headsets you have. Each takes several answers. Choose Not now to close it: it then comes up once each time the app starts, and a button with a red dot in the header opens it whenever you like, until you answer.
Your answers are kept with your Graspable account, so you are asked once whichever computer you use. If you are not signed in, they stay on this computer and are sent when you sign in. If you pick "Other" for how you heard about us, the few words you type are kept too. While Help improve Graspable is on, the same answers also go with your usage events.
The download link by email
On a phone, the website offers to email you the download link, because Graspable installs on a computer. If you use it, we keep your address, the tag of the link that brought you to the site (for example which post or ad), and whether you opened the email. We send that one email. If you ticked the box, three short tips from Michal follow over the next week, and news when something new ships; nothing else. Every email has a link that makes us forget your address.
Feedback
Feedback, at the top of the app, sends what you type to Michal, creator of Graspable.dev: what you are building, what got in the way, your words, and the app's version. Nothing from your projects, no prompts and no paths. If you tick Michal may reply to me by email, your account's address (or the one you type, when signed out) goes with it so he can answer.
Your email after a first scene
When your first scene finishes and you are not signed in, a small card from Michal offers free Credits for your email address. It is the same sign-in as in Settings, and it makes a free account. Close it and it does not come back. A new account gets a few emails from Michal over its first week, and every one has a link to stop them. When you sign in, the app also tells Graspable that it came from the app, and the website tells it which tagged link or site first brought your browser there, so we know which places send people.
The pages written for agents
When an assistant, search crawler or script requests a public reference on the website, Graspable counts its reported category and the public reference path. This includes the Markdown pages, agent discovery data, skill index and site search index. These counts contain no query parameters, IP address, account ID or prompt, and create no person profile. They count requests, not successful reads or recommendations. A browser's ordinary page analytics is separate.
Ratings
Under every agent message there are copy, 👍 and 👎 buttons. A rating is something you choose to send.
A rating sends the rating itself with the same kind of anonymized details as a summary: engine, model, instruction version, and what the agent had done so far. With 👎 you can pick reasons and type a comment, which is sent too.
The agent's message and your request are sent only when you tick Include this response and my request.
If you are signed out or offline, the rating is saved and sent later. The app tells you which.
What is never sent
Run summaries never contain:
- your requests,
- your code or file contents,
- file names or paths,
- the commands or other details of what the agent did,
- your memory.
API keys and sign-ins are never sent to Graspable.
Turn it off
Open Settings → Help improve Graspable and untick Send run summaries, error reports and usage of the app.
With it off, no summaries, no error reports and no usage events are sent from the app, and grasp and the MCP server stop counting their use too, and your runs are not placed in instruction tests. Ratings are separate: they are sent only when you click 👍 or 👎.
Where keys and sign-ins are stored
| What | Where |
|---|---|
| API keys for model providers | Your system's keychain |
| Your Graspable account sign-in | Your system's keychain |
| System One and cloud provider keys | Your system's keychain |
| ChatGPT sign-in for the Graspable agent | A file in ~/.graspable/agent on your computer |
| Claude Code sign-in | Claude Code's own storage. Graspable never reads it |
| Codex CLI sign-in | The Codex CLI's own storage. Graspable never reads it |
| Tokens of your cloud agents | ~/.graspable/cloud.json, readable only by you |
A key is read from the keychain when a run starts and handed to the agent on your computer. For a cloud project, the key is sent with the run to your cloud agent over an encrypted connection and is not stored there.
Other connections the app makes
- Updates: the app checks for new versions when you ask in Settings → Updates.
- Model lists: when it starts, the agent reads public lists of models (a model catalog, OpenRouter, Venice, Graspable for the models on Credits) and asks the public package registry for the newest version of Claude Code and the Codex CLI. These requests carry no key and nothing about you or your projects.
- Agent spending: when you switch it on, the agent asks a public catalogue for paid services and calls the services it buys from; payments go from the agent's wallet to the service. Graspable is not in that path and is told nothing about a purchase. The record of purchases is a file on your computer. See Agent spending.
- Routstr, paid with bitcoin: to list nodes, the app asks public Nostr relays for their announcements and then asks each node about itself. When you use a node, your requests go to that node and on to the model provider it uses; what a node keeps is up to the people who run it. Nothing about your balance is sent to Graspable.
- Credits paid with crypto: this is a purchase from Graspable, so Graspable keeps a record of it with your account: how many Credits, the coin and amount, the dollar value, the payment's reference on its network and, where the network shows it, the address that paid. To see whether your payment has arrived, Graspable asks public services about its own receiving address (block explorers, a price service, and for Lightning the service that issued the invoice). Your wallet is never asked for and never touched.
- Venice, paid with crypto: when you use it, your requests go to Venice, signed by the agent's wallet. To show what is in that wallet, the app asks a public node of the Base network for the balance of its address. Nothing about the wallet is sent to Graspable.
- Plans: Settings → Plan and Credits asks Graspable for the plan list and, when signed in, your plan.
- Headset sharing: when you choose Share on Wi-Fi, the preview is reachable on your local network until you stop. See Preview and headset.
- System One: when you are signed in, each thing it judges (a command, a saved note's title and text, a passage of an earlier run, a stretch of command output) is sent to Graspable and to our provider for that judgement, TypeSafe. Graspable stores how many were made, not what was judged. If you add your own model, it is sent there instead. Set the mode to Off to send nothing. See Approvals and safety.
Missing AI account settings are shown in the app without sending a crash report. Other request failures remain reportable while Help improve Graspable is enabled.