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.

  1. Phone Checks the hardware and the signed release first. Nothing is sent if they don’t match.
  2. Confidential VM Nobody can look inside, including us. Your key lives only here.
  3. Data Only the accounts you connect, only when a task needs them.
Always encrypted in transit and at rest. One key per account.

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.

  1. 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)
  2. 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 technology →   The proof →

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.

Workeragent · policy · approvals
Workerscheduler · watches
Workerresearch · browser sandbox

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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_digest to 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.