Built so nobody can read your data.
An assistant that acts for you needs your inbox and calendar. Here is why that access can’t be misused, by us or by anyone else.
- Phone Checks the hardware and the signed release first. Nothing is sent if they don’t match.
- Confidential VM Nobody can look inside, including us. Your key lives only here.
- Data Only the accounts you connect, only when a task needs them.
Three promises, in plain words.
Encrypted
Everything is encrypted in transit and at rest. What we store is locked with a key made for you, usable only inside the protected computer.
Sealed
Your assistant runs inside a protected computer that hides everything it handles from the people who run it, including us. Before your phone sends anything, it checks that the hardware and the software are the ones we published.
Erasable
Delete your account and we destroy your key. Anything encrypted under it, even in a copy, can’t be read again.
What we can and can’t see.
We can see
- That your account exists.
- When you use it, and roughly how much.
- How much encrypted data it holds, and error codes.
We can’t see
- Your emails and your calendar.
- Your conversations with the assistant.
- Your files, searches, and data.
Logs carry only identifiers, statuses and counts, never content. This is a design rule we test for, not a promise.
Delete means delete
Delete your account in the app and we remove your data, devices and sign-in links, revoke the permission we hold from Google, and destroy your key. Anything encrypted under it, even in a copy, can’t be read again.
Built for European privacy law.
Your data stays in the EU
We run in Google Cloud’s Netherlands region. Your data, its keys and the computers that handle it are all in the EU, under the GDPR.[1]
We can’t hand over what we can’t read
Authorities can ask any company for the data it holds. Yours is encrypted with a key only the protected computer can use, so there is nothing readable to hand over.
An honest note about our provider
Google is a US company, and US law such as the CLOUD Act can reach US providers wherever data is stored.[2] So we don’t rely on a promise: the data is encrypted with keys the provider’s staff can’t use.
Your rights, made real
The GDPR gives you access, correction and deletion. You can export your data in the app, and deletion is final because the key is destroyed.
Not legal advice. We describe what the sources say; legal conclusions about our product need counsel’s review before we make compliance claims.
- Google Cloud locations. https://cloud.google.com/about/locations (page did not render the region table to us; europe-west4 = Netherlands is stated from Google’s region documentation and should be re-checked)
- US CLOUD Act (2018): providers must disclose data in their possession, custody or control “regardless of whether … located within or outside of the United States”. Skadden, “Understanding the CLOUD Act’s Expansive Reach”. https://www.skadden.com/insights/publications/2018/12/understanding-the-cloud-acts-expansive-reach (read 17 Nov 2026; commentary, not the statute text)
Privacy you can check, not a promise.
For technical readers. Open a part below for what is built, how we prove it, and what is not done yet.
What stops it doing the wrong thingRisk levels, hostile content, known recipients, pause
What stops it doing the wrong thing.
Every tool has a risk level, and every call passes one policy engine. There is no shortcut around it.
Risk tiers
Reading is free. Drafting is free, because nothing leaves your account. Changing things needs approval; sending email or inviting people always needs a device-signed approval.
Hostile content
Emails, web pages and calendar text are wrapped as untrusted data. While untrusted content is in play, anything with side effects needs approval — a message cannot talk the assistant into acting. We test this with 25 attack scenarios.
Known recipients
Email goes to people you have written to before, unless you explicitly approve a new one. A new recipient is flagged on the card.
Spending and sites
For tasks on a website, you approve a plan with the one site, the exact details used and a spending limit; the final step is confirmed on your device before anything is submitted or paid. Early
Pause
One switch stops every side effect. It holds even for things you already approved, and survives restarts.
Only what is connected
If email or calendar is not connected, the assistant does not offer those actions at all, and says plainly what to connect.
Each person is walled offSeparate keys, attack tests, fair use
Each person is walled off.
Qoncierge serves many people on shared, attested hardware. Isolation is a tested property, not a convention.
Separate keys
Every account gets its own random encryption key, wrapped by a cloud key service that only releases it to a released, attested image. The account’s identity is bound into every encrypted field, so a row cannot be moved to another account and still decrypt.
Attack tests
An automated suite signs in as a second account and tries every route to reach the first account’s data. The answer must be identical to “that does not exist”. A scan fails the build if any query could cross accounts.
Fair use
Each account gets a fair share of the model, the browser and the scheduler, plus a daily allowance and a storage quota, so one account cannot starve the rest.
Delete means delete
Deleting your account removes your data and destroys your key. We also revoke the Google permission. Anything encrypted under the key is unreadable from then on, even in a copy.
The building blocksHardware, keys and the parts, plainly
Sealed hardware, verifiable code, ciphertext at rest.
Qoncierge is a TypeScript agent running as a signed container inside Google Confidential Space on Intel TDX, behind a native Swift app that verifies the hardware before it trusts the server. Durable state is ciphertext in Cloud Spanner, under per-account keys.
Where your data is, and who can see it.
Your iPhone or Mac
Swift 6 / SwiftUI app. The approval key lives in the Secure Enclave and signs with Face ID. Before connecting, the app verifies the server’s hardware attestation and checks the image against a signed release log embedded in the app.
Passthrough network load balancer (Google)
Forwards TCP only. It sees addresses and encrypted bytes, and cannot decrypt anything. Adds capacity without moving the trust boundary.
Attested enclave workers — Google Confidential Space, Intel TDX, europe-west4
Identical, stateless workers. The CPU encrypts their memory; the operator cannot read it. They run only a signed image whose digest is on the release list, and key release depends on that attestation.
Plaintext exists only here, only while a task runs.
Cloud Spanner
All durable state. Rows hold ciphertext plus ids and timestamps. Scales out by adding nodes.
Cloud KMS
Wraps each account’s key. Releases it only to a released, attested image.
Confidential inference
Model calls go to an attested confidential-compute provider, behind one interface with a second provider configurable.
Pub/Sub
Content-free signals between workers (“something new for account X”), so live updates arrive without polling. Built; its first live run is still ahead.
Everything outside the dashed boundary is treated as untrusted: it sees only ciphertext, ids, sizes and timing.
One key per account, bound into every ciphertext.
Per-account keys
A random key per account, wrapped by Cloud KMS. The wrapping key releases only to a released, attested image — and production images must have debug disabled.
Bound to the row
Content is encrypted with XChaCha20-Poly1305 (libsodium). The authenticated data includes the account, table, column and row id, so a ciphertext cannot be moved elsewhere and still open.
Crypto-shredding
Deleting an account destroys its key. Every copy of its data — including backups and old versions — is then unreadable.
What it is built from.
| Layer | Choice | Why |
|---|---|---|
| Client | Swift 6 (strict concurrency), SwiftUI, iOS 26+ and macOS; Secure Enclave keys; no third-party SDKs, analytics or crash reporting | Native, small attack surface, hardware-held approval keys |
| Agent | TypeScript (strict), Node.js LTS, Fastify, Zod; model access through one interface, no provider SDKs | No lock-in; a second model provider is always configurable |
| Runtime | Google Confidential Space on Intel TDX, container pinned by digest | Hardware-encrypted memory and signed attestation tokens |
| Data | Cloud Spanner (PostgreSQL dialect), ciphertext only; portable SQL so SQLite serves development | Scales to many accounts without re-architecture |
| Keys | Cloud KMS, per-account keys, libsodium AEAD | Deletion destroys readability |
| Network | Passthrough load balancer; the enclave obtains and serves its own certificate (ACME TLS-ALPN-01), shared across workers through the database | No middlebox ever holds plaintext or the key |
| Releases | CI builds the image by digest, signs it with a KMS key, records provenance; Google trusts only our repository’s tagged builds through short-lived identity, with no stored keys | Anyone can check which code is allowed to run |
| AI | Confidential inference with attested hardware (provider’s published design; we have not independently verified it) | Prompts are not readable by the model host |
How we prove itThe six-link chain, what a reviewer can check, what we test
How we prove it, and where the proof ends.
“Trust us” is the problem we are solving. So the app verifies the server itself, with checks anyone can inspect, and we say plainly what those checks do not cover.
Six links. If one breaks, nothing is sent.
-
Signed build
CI builds the image by digest, signs it with a Cloud KMS key and records provenance. Google trusts only our repository’s tagged builds, through short-lived identity — there is no long-lived signing credential to steal.
-
Signed release log
A small list of allowed image digests (and revoked ones), signed with the same key. Its public key is embedded in the app. Adding a digest is a reviewed change.
-
Hardware attestation
The server returns a token signed by Google’s Confidential Space attestation service. It states the hardware (Intel TDX), that secure boot is on, that the image is not a debug build, our project, and the exact image digest.
-
Offline verification on your phone
The app verifies the token’s signature up to Google’s pinned root, checks freshness and a nonce it just generated, and checks that the image digest is in the signed release log and not revoked. Debug builds are refused.
-
The connection is bound to the code
The token includes the hash of the TLS key. The app checks it equals the key the live connection used, then pins that key. You are talking to the attested code, not something in front of it.
-
Keys only for released code
Cloud KMS releases the data-wrapping key only to a workload whose attestation names a released digest — and production images must have debug disabled. A modified image gets no key and cannot read anything.
Checks 3–5 run on the device, every time it connects. A server that fails shows “can’t verify this server” and receives nothing.
What a reviewer can check.
Today, on request
- Fetch the attestation token from a running instance with a fresh nonce and decode it with any JWT tool; the claims are plain.
- Verify its signature against Google’s published Confidential Space root.
- Compare
image_digestto the signed release log in the app. - Verify the image signature with our public key using
cosign.
curl "https://<host>/v1/attestation?nonce=$(openssl rand -hex 16)"
Next
- A public, signed release log mapping each digest to its commit and provenance.
- A “verify it yourself” page with these steps as copy-paste commands.
- An independent security audit, published.
- Source publication and reproducible builds, so the digest can be rebuilt from source.
Until the public log exists, the strongest claim we make is the one the app enforces, not one we ask you to take on faith.
What we test, and the numbers.
650+ server tests
Policy, approvals and signatures, redaction, scheduling, isolation and encryption, on both the SQLite and Spanner backends. They run in CI on every push (count at 17 Nov 2026).
Isolation attacks
A second account tries every route to the first account’s data and must get the same answer as for something that does not exist. A scan fails the build on any query that could cross accounts.
Prompt-injection evals
Against a live model with a synthetic mailbox and calendar: 25 hostile-content cases (email bodies, forged approvals, calendar text, search results) with no unapproved side effect; 13 of 13 task scenarios pass (run of 15 Nov 2026).
Evals run against synthetic data only. “Safe” means no unapproved action executed; a run that errors counts as inconclusive, never as a pass.
Still to comeStated precisely, with dates
Built, in staging, and next — stated exactly.
Updated 17 November 2026. Built works and is tested in our staging environment. Next planned, not built.
| Capability | State | Notes |
|---|---|---|
| Attestation checked by the app before any request | Built | Offline token verification, TLS key binding, signed release log, debug images refused (except a debug build of the app pointed at staging) |
| Per-account keys, deletion that destroys the key | Built | Account id bound into every ciphertext; Google grant revoked on deletion |
| Approval-first actions, signed approvals (a tap, or Face ID for payments), undo | Built | Policy engine, untrusted-content handling, recipient allowlist, pause switch |
| Google mail and calendar | Built | Google’s app verification for broad public use is not done; we run in testing mode with invited users |
| Spanner backend, stateless workers, shared certificate, events | Built | Two-worker run on staging; the Pub/Sub event path has not yet run live; no load test yet |
| Invite-only sign-up with approval; Sign in with Apple | Built | No codes to type |
| Staging environment | Staging | Runs debug images with synthetic and tester data; production policy refuses debug images |
| Production environment and public launch | Next | Cutover is a prepared runbook; happens before launch |
| Public release log and “verify it yourself” page | Next | The signed log exists and ships in the app; the public copy is scheduled |
| Independent security audit; reproducible builds | Next | Builds are signed with provenance today; byte-for-byte reproducibility is not claimed yet |
| Microsoft mail and calendar | Next | The code is already provider-neutral; Google is the only provider implemented |
| Messaging channels, agent-to-agent scheduling | Later | Chat apps would see message text, so sensitive results would use a secure view |
What the proof does not cover.
A privacy claim is only worth what its limits are worth. These are ours.
| Limit | What it means |
|---|---|
| Metadata is visible to us | That an account exists, when it is active, row counts and sizes, the activity log (actions and results as ids, not content), and server logs of ids, statuses and durations. Not content. |
| The enclave sees plaintext | Your data is in the clear inside the enclave while a task runs. The guarantee is that no one outside can read it, and that you can verify what code is inside. |
| A bad release is a bad release | Code on the signed list that is itself malicious would see the accounts it serves. Controls: signed, listed and attested releases, your phone’s check, revocation, review, and — next — public logs, reproducible builds and an audit. |
| We trust the hardware vendors | Intel TDX and Google’s attestation service are the roots of trust. Hardware and side-channel attacks on confidential computing are an active research area; no enclave is invulnerable. |
| Third parties still handle data | Google and Microsoft hold the mail and calendar you connect. The AI model host sees prompts inside its own confidential hardware (its published design; not independently verified by us). Apple’s push service carries no content, only a type and an id. |
| Staging is not production | Staging runs debug images, which the app and production policy refuse, so staging does not prove production. The production cutover is ahead of us. |
| No audit yet | No independent audit has been done. We will not describe the system as audited until one is published. |