Privacy posture
Last updated
Solenoid keeps the map, not the territory. We’re built so a security-minded team can connect on day one: your raw source content transits Solenoid, is processed transiently, and is not stored, with two narrow exceptions described under Meetings and Slack. We separately describe the narrow, anonymous usage telemetry used to understand whether the marketing experience works, and the product usage events our servers record when your workspace uses the app.
The posture in one line
Reads your sources · writes only the changes you approve · BYOK · raw content processed transiently · never stored, apart from one short quoted line behind a decision proposed from a meeting, kept at most 30 days, and the messages of the Slack channels you choose, kept encrypted for 90 days · every answer cited.
What we never store
We never store your meeting transcripts, meeting notes, meeting titles, customer calls, or strategy. Your tickets, code changes, threads, and documents are processed transiently and discarded. Raw content submitted through a marketing or free-tool path is not stored by that path and is not included in usage telemetry; an email address you leave there is kept only as described under Email capture. When you use the free run on a public project, we keep a one-way code made from your IP address, so each address gets one run a day. We also keep your result: up to five theme names, each with its share, count and roadmap match. We delete both within an hour after they are 24 hours old. There are two narrow exceptions for what Solenoid reads from your sources: a decision Solenoid proposes from a meeting is kept with one short line quoted from that meeting as its evidence, for at most 30 days, as described under Meetings; and the messages posted in the public Slack channels you choose are kept encrypted for 90 days, as described under Slack. Apart from those, there are no database schemas for your raw content — we keep only pointers, derived metadata, and citations back to your own sources.
Anonymous marketing telemetry
When marketing telemetry is enabled, Solenoid sends anonymous pageview events to PostHog, our product-analytics processor. The event contains a non-identifying, per-tab random id and the ordinary URL path needed to count the page. It does not contain URL query strings or fragments, referrers, raw submitted content, or known dynamic capability ids such as a free-tool run UUID.
These events explicitly disable PostHog person profiles. The PostHog environment is also required to discard client IP data before browser telemetry can be enabled, so the IP is not retained with the event. As with any direct network request, PostHog may process the address transiently before discarding it; our promise is no IP retention, not that the processor cannot see a network connection.
Product usage events
When your workspace does something in the app, Solenoid’s servers record a named product event. We keep these events in Solenoid’s own database and, apart from the two marked below, also send them to PostHog, the product-analytics processor named above. They come from Solenoid’s servers, not from your browser. Solenoid deletes each event from its own database 90 days after it was recorded. PostHog keeps every event sent to it, from our servers or your browser, for one year.
Each event is labelled with an opaque pointer to your workspace — never a name, an email address, or a sign-in id.
An event recorded while our servers answer one of your requests also carries that request’s id, a random value our logs use for the same request.
Creating your workspace (workspace.created), your AI’s first call through Solenoid
(connector.ai_connected), signing in (user.signed_in), signing out (user.session_ended), turning on a scheduled run
(demand_map.schedule_enabled), sharing a map (share.minted), uploading a
Slack export (slack_export.uploaded), Solenoid creating a new project in your GitHub
account (onboarding.new_project_created) and connecting it
(onboarding.new_project_connected), choosing Start a new project
(onboarding.new_project_started), starting to connect Slack
(connector.slack_connect_started), and disconnecting Slack
(connector.slack_disconnected) carry nothing beyond the event’s name, the
workspace pointer, a timestamp and the request’s id above. Beyond those, the other events
carry only these fields:
- Signing up (
user.signed_up) — a source field saying where the sign-up started, one of three fixed values: the demo walk, the homepage, or unknown. - Starting a run (
demand_map.run_started) — an identifier of the run. - Completing a run (
demand_map.run_completed) — an identifier of the run, the number of themes found, and how long the run took in milliseconds. - Completing your first real map (
first_real_map_completed) — an identifier of the run, the number of sources read, and the number of themes found. - Deciding on a recommendation (
recommendation.decided) — whether you approved or dismissed it. - Starting an upgrade (
subscription.upgrade_started) — an identifier of the Stripe checkout session. - Saving your AI key (
byok.key_added) — which AI provider the key is for, and whether it replaced a saved key. Never the key or any part of it. - Removing your AI key (
byok.key_removed) — which AI provider the key was for. - Connecting GitHub (
connector.connected) — which source was connected (GitHub);connector.github_connectedis recorded with it and carries nothing more. - Connecting Slack (
connector.connectedandconnector.slack_connected) — which source was connected (Slack), and whether it was a first connection, the same Slack workspace connected again, or a Slack workspace moved over from another Solenoid workspace. - Choosing Slack channels (
connector.slack_channels_selected) — the number of channels chosen. - Completing an upgrade (
subscription.upgrade_completed) — an identifier of the Stripe subscription. Kept in Solenoid’s database only, not sent to PostHog. - Opening a customer demand (
artifact.opened) — an identifier of the run and of the demand opened. Kept in Solenoid’s database only, not sent to PostHog. - An error shown to you (
customer_error_shown) — your browser reports it and Solenoid’s servers record it. It carries which part of the app showed it, which of a fixed list of reasons it was (with a fixed detail for one of them), what kind of failure it was, which step stopped, an identifier of the request, an identifier of the page view, and when it was shown. Both identifiers match the record of that request in Solenoid’s server logs, which Solenoid uses to find what went wrong. An error that arrives already written in a page is recorded in Solenoid’s server logs instead. That line carries the part of the app, the reason, the kind of failure, the step, an identifier of the request, the page’s path and, when you are signed in, an opaque identifier of your account. On a card’s change panel it also carries an identifier of the card and, for one of its reasons, a fixed detail. - Watching a task run (
task_run_observed) — your browser reports it and Solenoid’s servers record it when the page watching a running card gets its final answer. It carries an identifier of the card, which stage it was at, how many times the page checked and how many checks failed, how long it waited, which state the card ended in, and an identifier of that wait. - Pressing Upgrade (
paywall.upgrade_pressed) — your browser reports it and Solenoid’s servers record it. It carries which part of the app showed the button, whether you are an owner or a member, whether an AI key is saved, whether your workspace had one free map or more, and an identifier of the press.
Working through tasks and decisions records one event per step, carrying only an identifier of the card or an identifier of the decision, which stage the card was at (spec, design or build), whether it came from the app, your AI or a background job, for a retried card, whether it was a retry or a redirect, and, for a project-setup step, which setup action it was and, when the setup stopped, which of a fixed list of reasons it stopped for:
- Tasks — a card added to your backlog (
task.card_seeded); a card Solenoid picked up and started (task.picked_up); a spec written (task.spec_written); a design started (task.design_started) and ready for you (task.design_ready); a spec, design or build approved (task.spec_approved,task.design_approved,task.build_approved); a change opened (task.change_opened) and confirmed as added to your code (task.merge_confirmed); a card sent back (task.card_sent_back), retried (task.card_retried) or dismissed (task.card_dismissed). - Project setup — your project chosen (
task.project_bound); the setup plan shown (task.setup_plan_previewed); a setup step that stopped (task.setup_failed); the setup plan approved (task.setup_plan_approved), its change opened (task.setup_change_opened) and confirmed as added to your code (task.setup_merge_confirmed). - Decisions — a decision recorded from your AI (
decision.note_recorded), confirmed (decision.note_confirmed), discarded or taken back (decision.note_discarded), or started as a task (decision.task_started).
One event comes from your browser instead: choosing Add your AI key on Plan & Usage
(billing.byok_cta_clicked) is sent to PostHog only, with the workspace pointer and
the page name.
The setup steps panel in the app sends six events from your browser, to PostHog only,
with the workspace pointer. Five carry nothing else: the panel shown
(onboarding.panel_shown), hidden (onboarding.panel_hidden), brought back from
Setup (onboarding.panel_restored), reopened once by Solenoid
(onboarding.panel_resurfaced), and finished (onboarding.panel_completed). Opening
a step (onboarding.step_opened) also carries which setup step it was, one of five
fixed values: GitHub, the AI key, connecting your AI, Granola, or a customer source.
The Connect your AI screen right after you connect GitHub sends four events from your
browser, to PostHog only, with the workspace pointer and nothing else: the screen shown
(onboarding.ai_step_shown), your AI’s first call seen there
(onboarding.ai_step_connected), your AI key saved there (onboarding.ai_step_key_saved),
and the screen skipped (onboarding.ai_step_skipped).
Two events come from your browser on the demo pages, before any workspace exists. They are sent to PostHog only, labelled with a random id made for that browser tab, which ends when the tab closes, and not with a workspace:
- Opening an action preview (
demo.action_previewed) — which demo stop it was on and which action was previewed: comment or approve. - Leaving the demo (
demo.cta_clicked) — which demo page the click was on and which way out was chosen: starting free, connecting your own project, or the free run on a public project. Never the address of the link.
Nothing else is attached: no source content, no theme or decision text, no card, project or branch name, no transcript, no names or email addresses, and nothing you typed. Events from Solenoid’s servers are checked against a list of forbidden fields before they are sent. Events from your browser can carry only the label and the fixed values listed above.
Server logs
Solenoid’s servers write operational logs to Axiom, our log provider, which deletes them after 30 days. A log line can carry identifiers: of your workspace, your account, your billing account, the request, card or run it concerns, your GitHub installation, and a Slack workspace, channel or message. It can also carry the page or step it came from, the name of a GitHub project Solenoid reads, with its account’s name, a one-way code made from an email address left on a demo page or the waitlist, and, when something fails, a description of the error.
What Solenoid reads, and the changes it writes
Solenoid reads from your sources. What it writes is a proposed change: only in a project you’ve enabled, only when you approve that run. In a project with no commits yet, it first adds one file, a README, as the first commit, when you approve it. When Solenoid offers to start a new project and you press Start a new project, it creates one private project from its starter in the GitHub account you choose, with your own GitHub sign-in.
GitHub shows the permissions before you install: read access to issues and metadata, read and write access to code and pull requests, and Repository creation, which Solenoid uses only to create the one new project you start. The write access is broader than what Solenoid does with it. Solenoid’s own code can create a new branch, open a proposed change you approved and, when you approve the setup plan, add that change to your project. It can also add the first file to a project that has none when you approve it. It has no other route to change the main version of your project or to approve a change itself, and it opens nothing you have not approved.
Linear issues are read as content in the moment; only the derived result is kept — a cluster or count — never the raw text. Slack messages are the one kept source content, described under Slack.
You see the scopes before you authorize. Per source:
- GitHub — reads issues and code changes; the write access GitHub shows you is used only to open a proposed change you approved, to add the setup change when you approve it, or to add an empty project’s first file when you approve it. For each issue and code change it keeps the link, state, label ids, comment count and dates, and the GitHub login of the person who opened it, never the title or text.
- Linear — issue identifiers, counts, and timestamps are persisted; titles, descriptions, and label names are not.
- Slack — the messages of the public channels you choose, kept encrypted for 90 days and read only when Solenoid builds your map; see Slack.
- HubSpot — company and deal metadata (revenue, lifecycle stage, amount,
stage, and close date). Live v0 requests no contact scope and reads no contacts.
It also asks for HubSpot’s
oauthpermission, used only to remove the Solenoid app from your HubSpot account when you delete your Solenoid account.
Slack
When you choose channels for Solenoid to read, it keeps the messages posted in them, so it can read them at the pace Slack allows and build your map from them.
What Solenoid keeps. The text of each message posted in the public channels you chose, with its time, its channel and thread, the Slack id of the person who posted it, and its reaction counts. Never names, email addresses or profile details, and never direct messages, private channels, files or channels shared with another organization.
How, and for how long. The text is encrypted when it is stored and is read only when Solenoid builds your map. Each message is kept for 90 days from when it was posted, then deleted, and an hourly check makes sure nothing older remains.
When it is deleted sooner. Removing a channel from your choice deletes its messages at once. Disconnecting Slack or removing the Solenoid app deletes every message kept for your workspace at once. A message deleted in Slack is deleted here, and an edit replaces it, as soon as Slack tells Solenoid; a deleted message stays deleted even if Slack sends it again, and an older edit Slack delivers late does not replace a newer one. A channel deleted, archived or shared with another organization has its messages deleted as soon as Slack tells Solenoid, and a channel made private within the hour, when Solenoid next checks your channels.
One limit remains. In a workspace with more than 1,000 public channels, Solenoid cannot always see that a channel was made private, so its messages are deleted once they are 90 days old.
Meetings
You can connect Granola or upload a meeting transcript. This section explains what Solenoid reads and keeps when you do.
What Solenoid reads, and from where. When you connect Granola, you sign in on Granola’s own page and Solenoid reads the AI notes of your meetings from Granola — and the transcripts too, on a Granola plan that offers them to connected tools. When you upload a meeting file, Solenoid reads that file. It reads them to find the decisions your team made and what customers asked for. Notes are read for decisions only; what customers asked for comes only from their own words in a transcript.
What connecting Granola lets Solenoid read. Granola’s sign-in is all or nothing: until you disconnect, it lets Solenoid read every note your Granola account can see, not only the meetings you choose, and anyone holding that sign-in could also use Granola’s own chat and folder tools. Solenoid asks Granola only for your meetings: their notes, and their transcripts where your Granola plan offers them. Its own code calls only the Granola tools that list meetings, read a meeting, identify the connected account, and sign out, and refuses every other. That limit is kept by Solenoid, not by Granola. On Granola’s free plan, Solenoid can read the notes from the last 30 days and no transcripts; transcripts need a Granola Business plan.
Your AI key, and no training. Reading a meeting uses your own AI key, under your AI provider’s terms. Solenoid does not use your meetings to train anything.
What is kept, and for how long. Transcripts, notes, and meeting titles are read while Solenoid works on them and are not stored. Solenoid keeps only:
- A proposed decision, with one short line quoted from the meeting as its evidence, its date, and a link back to the meeting, for at most 30 days while it waits for you. Attendees’ names in that line are replaced by their role; a name spoken in the meeting can remain. If you approve it, the evidence line is erased and the decision is kept like any decision you record. If you discard it, or it waits 30 days, its text and evidence line are erased and only a blank marker stays, so it is not proposed again.
- Which meetings were already read, as coded identifiers with no text, plus dates and counts, so a meeting is not read twice and a discarded proposal does not come back.
- What customers asked for, as short theme labels with counts, dates, and links back to the meeting.
- Short labels from fixed lists: what kind of meeting a proposal came from, whether its evidence line came from notes or a transcript, how each imported meeting was classified (with a short reason code when it is unknown), and which Granola plan the connection reads.
- Your team’s email domains (the part of an address after the @), with no names or addresses, so Solenoid can tell your team’s voices from your customers’.
- Solenoid’s copy of the Granola sign-in, encrypted, never shown and never logged, until you disconnect.
- Which Granola account and workspace are connected: for each, Granola’s identifier or else a one-way code derived from the account’s email address or the workspace’s name — never the email address or the name itself.
Everything in this list except a proposed decision (which follows its own 30-day rule above) and your sign-in stays after you disconnect, until you ask us to delete it.
Disconnecting. Disconnect signs Solenoid out of Granola when Granola can be reached, and deletes Solenoid’s copy of the sign-in and its sync position. Your approved decisions, customer themes, and everything else listed above stay. If Granola does not confirm the sign-out, Solenoid says so and still deletes its copy.
Consent. When you connect Granola or upload a meeting, Solenoid shows this line once, inside that step: “You’re responsible for having consent to record these calls. Solenoid reads meeting notes and transcripts for decisions, and eligible customer-call transcripts for what customers asked for; it never stores the full notes or transcript or trains on them.”
Designs
When Solenoid designs a screen for one of your task cards, it draws the design and keeps the pictures, so the card can show them.
What Solenoid keeps. The pictures of a card’s design rounds, and for each drawing a record of how it went: counts, the names of the screens it drew, and labels from fixed lists, with no addresses. Solenoid keeps none of your project’s style files; a design may use the names they define, such as the name of a colour or a class.
For how long. A card keeps the pictures of its 5 newest rounds, and a workspace keeps at most 512 MiB (about half a gigabyte) of pictures, deleting those of closed cards first, then the oldest. When a card closes, because its change was added to your code or it was dismissed, its pictures are deleted 30 days later. The written design stays with its card.
When they are deleted sooner. Disconnecting GitHub deletes every picture at once, and uninstalling Solenoid’s GitHub app does so as soon as GitHub tells Solenoid. Removing a project from Solenoid’s access in GitHub deletes the pictures of that project’s cards. Pictures are deleted with their card and with their workspace, including every workspace deleted with your account.
Connecting your AI to Solenoid
The sections above describe connectors that read from your sources. The AI connector runs the other way: you connect Claude (or another MCP client) to Solenoid, and your assistant can then ask Solenoid questions and record decisions on your behalf. Because that direction can write, it is described separately here.
What it can read. Everything it reads is scoped to your own workspace. Every connection can read:
- your ranked demand themes (
demand_map:read); - what changed between your two most recent maps (
demand_map:read); - whether a map run has finished, how far one has got, and which workspace the
connection reads (
demand_map:read); - your Tasks board: each task’s title, column, status and next step, as the
Tasks page shows them (
tasks:read).
These return Solenoid’s derived output — clusters, weights, counts, timestamps, citations — under exactly the posture above. Connecting your AI does not give it a new path to your raw source content, because its tools return only derived output. A workspace owner’s own connection can also read:
- the decisions waiting for your confirmation, as the Pending list shows them:
title, decision and context. A decision proposed from a meeting comes without
context or the line quoted from the meeting (
founder_notes:write). - a decision found by words you remember from its title or text, whether pending,
confirmed or discarded: its title, decision, status and dates. Your words are
not stored, and the text of a discarded meeting decision, which Solenoid erases,
cannot be found (
founder_notes:write).
What it can change. With a workspace owner’s connection, and only with it: A workspace member’s connection can read these results but cannot make these changes.
- Recording a decision. Needs
founder_notes:write; asking for a task as well also needstasks:write. When you ask your assistant to log a decision, we do store the note you asked us to keep: its title, the decision statement, and any context you include. This is a deliberate exception to the “we keep the map, not the territory” posture — a decision you explicitly asked Solenoid to remember is the map. Every recorded or edited decision waits as pending until an owner confirms it on the Company Decisions page or from their own chat. Your assistant can confirm, edit or discard a decision you recorded through it. It is instructed to read the decision back and ask whether to confirm it and start a task; Solenoid cannot verify that exchange. Decisions from meetings or teammates must be confirmed on the page. If you also ask for a task, Solenoid adds one card to Tasks; writing its spec uses your AI key and the spec waits for your approval. - Starting a map run. Needs
demand_map:run. When you ask, your assistant can start the same run the app’s button starts, under the same free-run allowance, cost limits and one-run-at-a-time rule. It reads the sources you connected, as described above. - Acting on a task card. Needs
tasks:write. When you ask, your assistant can press a task card’s own buttons (start it, approve its spec, send back its spec or design, try again, start over, or Not this one) through the same checks the card page runs. A direction you give when sending a card back is stored on the card, exactly as when you type it on the page. Your assistant can also approve your project setup. It first reads back the project, how the change is added, and the name and size of every file it adds, plus the text of any file it opens; your assistant’s provider receives what it reads back. It approves on a second call, which works once, within ten minutes, for exactly what it read back, and which it is told to make only after you say yes. Designs and code changes are approved on the card page. - Scheduling map runs. Needs
demand_map:run. When you ask, your assistant can turn your scheduled map runs on, change how often they run, or turn them off, after reading the schedule back to you. Scheduled runs use your own AI key.
Solenoid marks these write tools with the standard destructive hint. Whether and how your AI client asks before running one is that client’s setting, not something Solenoid controls, so check the tool permissions in your client (in claude.ai: Customize → Connectors → the connector’s Tool permissions). It cannot reach another workspace: every call is bound to the workspace the connection authenticates, and a request that cannot be resolved to exactly one workspace is refused rather than guessed.
Storage and retention. Recorded decisions are kept in your workspace. You can discard a decision, whether it is pending or already confirmed. Either way Solenoid stops using it from the next map and it can never be confirmed again; maps already built keep it until the next run. A decision you or your assistant asked Solenoid to keep is set aside rather than erased when you discard it, and we retain the record. A decision Solenoid proposed from a meeting is different: discarding it, before or after you confirmed it, erases its text (and its evidence line, if it was still waiting) and leaves only a blank marker, as described under Meetings. To have decisions permanently removed, ask us and we will delete them. Tool calls also produce an operational record used to run and debug the service: which tool ran, which workspace, and a size estimate. It also records when the call was made, how long it took and whether it worked. The permissions a connection holds are logged only when a call is refused for lack of one or when the list of tools is served. The per-call record carries no note text, no theme content, and no conversation content. We delete each record after 30 days. When an AI uses your workspace through the connector, we keep when it last did, once for the workspace and once for each kind of AI: Claude, ChatGPT, or a connection key, so the app can show that it worked. These times do not say who asked or what was asked.
Third parties. Connecting your AI adds no new processor on our side, but it does put your assistant’s provider in the data path, and we want to be exact about how. When your assistant calls a tool, Solenoid sends the result directly to that provider’s infrastructure — that is how the answer reaches your conversation. So workspace-derived data does leave us for your provider, every time a tool runs.
What stays true is who starts it: that transfer only ever happens in response to a call your assistant makes under your authorization. We never push your data to a provider on our own, and we hold no connection you did not create. Once the result reaches them it is governed by your agreement with that provider. You can disconnect at any time from your AI client’s own connector settings, and no further data leaves us for it.
Authorization. The connection uses OAuth 2.1 with PKCE; sign-in is handled by our identity provider and we never see your password. If you connect a command-line client instead, its access token is shown once, stored only as a one-way hash, and can be revoked from your Solenoid settings at any time.
Questions, or a deletion request — including permanently deleting recorded decisions — reach us at ops@solenoidagent.com.
BYOK — your provider, your terms
LLM inference runs on your own AI key — you’re billed by your provider for inference, by us for the brain. Retention and training are governed by your AI provider’s terms for your account — check them. With an OpenAI key, we ask OpenAI not to store each request; OpenAI can still keep a request for up to 30 days under your account’s terms. Your free first map runs on Solenoid’s key; after that, your maps run on the key you add. We’re precise about what hosted means: your content does transit our pipeline to be processed, so
we claim never stored (apart from the meeting evidence line and the Slack messages above), not “never seen” — the stronger never-sees posture is the Enterprise tier below.
Every answer cited
Every claim, quote, decision, and constraint links back to its source — a permalink, a code change, an issue. If we can’t cite it, we don’t say it.
Email capture
When you join the waitlist, we keep a one-way salted hash of your email, to de-duplicate signups, with the page you joined from and when. On our side, the address itself stays only in the record of the job that sends the walkthrough you asked for, which is deleted 30 days after the job ends. We use Resend to send.
When you leave your email on a demo page, we send one reply to it, and our Slack is told its first three letters, its domain and a one-way code made from it. The full address stays in the record of that job, which is deleted 30 days after the job ends.
When you sign up, we keep the email address you sign in with, our identity provider’s id for your account and when you joined, so we can recognize you and write to you. They are deleted when you delete your account. If you unsubscribe from our emails, we keep your address, the reason and the date on a do-not-send list so we never write to it again. We delete it with your account if it is still one of your account’s addresses; otherwise it stays on the list until you ask us to remove it.
What we keep after you delete your account
After you delete your account from Settings, these records may remain:
- Encrypted database backups expire under our retention policy.
- Stripe keeps invoices and payment records as the law requires.
- We keep a restricted deletion receipt with hashed identifiers for 24 months to prove erasure and recognize duplicate requests.
- Operational logs and data from your free first map may remain with their providers under their retention policies. Our email provider keeps email we sent you for 30 days.
- Product analytics data linked to your account may remain with our analytics provider for up to one year.
- We keep the cost figures of past AI calls: the model, the kind of job, token counts, cost, how long each took, whether it worked and when. Every link to you, and to each workspace deleted with your account, is removed.
A key you gave Solenoid, such as your AI key, keeps working at its provider until you revoke it there. Solenoid deletes its copy along with the workspace it is saved in.
This page summarizes our privacy posture.
▸ Regulated industry (healthcare · finance · government)? The Enterprise tier runs the data plane inside your own environment — the stronger never-sees posture, where your content never leaves your infrastructure (ADR 0070). On our roadmap for regulated buyers — talk to us.