Security & isolation
read as.mdGuuey runs other people’s agents on shared infrastructure, so isolation is not a feature bolted on afterwards — it is the shape of the runtime. This page describes the mechanisms as they exist today: how workloads are isolated, what the network lets them reach, where credentials live, and what happens to stored data when someone asks for it to be gone. No compliance badges, no adjectives — just what the platform does.
This page is the one-screen inventory. The why underneath each section has its own page: How hosting works for the runtime, The identity model for tokens and verification, BYOK & credential custody for key sealing, and The MCP proxy for brokered tool calls. Permission boundaries lists the guarantees about what a guest, a signed-in user and a builder can reach, and counts only those enforced on this version of Guuey.
Runtime isolation
Section titled “Runtime isolation”Every deployed app gets its own long-running pod in its own Kubernetes namespace. Every hosted workload — a no-code agent’s pod, a code-mode agent’s image, an MCP server you host on Guuey — is sandboxed with gVisor: system calls from your process hit a user-space kernel, not the host’s, and each hosted MCP server gets its own gVisor-sandboxed pod, separate from every agent and every other server. A no-code agent’s pod runs Guuey’s own runtime image under that same gVisor boundary; on top of it come the namespace, the default-deny network below, and the jail around the worker described next.
Resource limits are structural, not advisory. Each pod size (xs–xl) maps to a fixed CPU and memory allocation, and how many pods an app may run is capped by its plan — see Pod sizes and scaling. A runaway workload exhausts its own pod, not its neighbours’.
Behind the pod boundary there is a second wall: the worker that runs your turns — Guuey’s own runtime worker for a no-code agent, your program for a code-mode one — starts from a cleared, allowlisted environment. The allowlist carries paths and configuration. In a no-code app, variables and secrets your app declares itself can also reach the worker, through the env block of your guuey.json and any ${env.NAME} header you declare, but by design Guuey does not place its managed model keys or your BYOK model keys there. Guuey gives that worker neither the agent pod’s cloud identity nor a Kubernetes service-account token, so code that escapes your own logic is not handed a credential for the cluster or for Guuey’s cloud account.
Network posture
Section titled “Network posture”Agent namespaces are default-deny in both directions, with explicit allows for exactly what an agent needs:
- DNS to the cluster resolver.
- Inbound traffic only from Guuey’s ingress stack — nothing else in the cluster can connect to your pod.
- Outbound TCP to the public internet, with private and internal address ranges excluded: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 100.64.0.0/10 and 169.254.0.0/16 (see hosted network rules).
The exclusions are the point. A compromised agent pod cannot reach other tenants’ pods, in-cluster services, the cloud provider’s instance-metadata endpoint (so no node-credential theft), or the Kubernetes control plane — with one deliberate, narrowly scoped exception: a pod may annotate its own pod object so the autoscaler doesn’t disrupt a conversation mid-turn, and RBAC bounds that door to exactly that one operation in the pod’s own namespace. What’s left is an agent that can talk to the internet under its own identity and to nothing of yours or anyone else’s.
The hosted-MCP data plane uses the same model: its namespaces are default-deny with explicit allows for the specific flows the design calls for, and hosted MCP servers accept traffic only from Guuey’s gateway.
Identity & verification
Section titled “Identity & verification”End-user identity is whatever your app declares, verified the same way on every surface:
- Bring your own auth: you point the app at your OIDC issuer, and Guuey verifies your users’ ID tokens against your provider’s published keys. Guuey never holds your signing key.
- Guuey’s per-app issuer: tokens are bound to your app’s own issuer and audience, and both are checked on every verification — a token minted for one app is structurally useless at another. The app secret your backend uses to mint tokens is printed once at creation; only its hash reaches storage, and there is deliberately no route to read it back. The key that actually signs the tokens is a per-app keypair sealed under Guuey’s KMS — never exposed by any API, unsealed only inside Guuey’s signer for the moment of a mint.
- Anonymous guests are supported where the app allows them: guest turns are capped per app, and guest storage is deliberately ephemeral.
Internally, when an agent pod calls a platform service — the MCP gateway, thread history, hosted state — it authenticates with a short-lived, KMS-signed federation token scoped to one user and one resource. A stolen token is minutes from useless and was never good for anything beyond the one thing it named.
Gateway logging is redacted by design: request lines carry the method name, never the payload, and OAuth callback parameters are dropped from logs before they ship anywhere.
Credential custody
Section titled “Credential custody”Bring-your-own model keys (added in the console under Behavior → Model or the workspace Provider keys panel) are encrypted with AWS KMS before they are stored; the ciphertext is bound to an encryption context naming its owner, so a blob can’t be replayed for another account, app, or workspace. A key is decrypted only to be placed where your own app uses it — never into another tenant’s reach.
Managed model keys are, by design, not handed to your agent’s code. Model calls go out through a Guuey-run proxy that holds the credential and adds it on the way upstream. By design, the environment your agent’s code runs in does not carry the key.
Hosted MCP server secrets (guuey mcp secrets set) are stored as KMS ciphertext. The plaintext never persists, is never baked into a server image, and is never returned by any API — the list endpoint returns names only. The gateway decrypts and injects a secret per invocation, for that server’s own upstream calls.
OAuth connections to third-party MCP servers go through Guuey’s credential broker. The authorization dance happens at the provider — Guuey receives tokens, never your users’ passwords. Tokens are KMS-sealed at rest, and the plaintext exists only inside the gateway process for the duration of a forwarded call:
- Your agent’s pod never holds a third-party token. It carries only a short-lived, KMS-signed Guuey federation token addressed to the gateway; the gateway checks the per-app grant and injects the real credential upstream.
- A user authorizes a server once; each app’s access to that connection is granted per app, explicitly, via a consent card in chat.
- Disconnecting deletes the stored credential (the KMS ciphertext is gone), drains every app grant on the connection, and makes a best-effort revocation call to the provider.
Data storage & deletion
Section titled “Data storage & deletion”What the platform persists, and where:
| Data | Where | Scope |
|---|---|---|
| Conversation history | DynamoDB | Per app, per user |
| Key-value state | Hosted KV | Per (user, MCP server), hard caps, TTL required |
| Home directory files | Per-user filesystem (durable where enabled) | Per (app, user), quota-capped |
Every primitive is scoped to one user. Conversation history and home files are also scoped to one app. Key-value state is scoped to one MCP server instead: a server sees the same user’s keys from every app that uses it. An agent can never read another user’s threads. Durable KV and the durable home are enabled per environment — State & memory states the current posture and the caps.
Deletion is built as a first-class path, not a support ticket:
- End users can delete their own conversations and memory (how, by kind of user); a user clearing their data is a fresh start, not an error.
- Builders get per-user portability and erasure verbs —
guuey mcp state exportandguuey mcp state wipeoperate on one user’s entries for one server that your workspace owns or that runs in your app (State & memory), andguuey apps byo-user erasedeletes one end user’s conversations and memory in an identified-mode app (below). - Account deletion is queued with a cancellation window, then a cascade deletes every user-keyed record across the platform’s tables, with an independent hourly sweeper as the fallback path. File erasure runs as an asynchronous wipe job per user directory, and a wipe that stalls raises an internal alarm rather than silently lingering.
Conversation history: retention and deletion
Section titled “Conversation history: retention and deletion”This is what an app’s privacy policy needs to say about the chat history Guuey keeps for its end users.
How long it is kept. Threads and their messages have no expiry. A conversation stays stored, for guests and signed-in users alike, on every plan, in an embedded chat or on a standalone page, until one of the deletions below removes it. Session records, the short-lived state of a live chat, are separate: they expire 30 days after their last activity.
Where it is stored. In DynamoDB, in AWS us-east-1 (US East, N. Virginia).
Logs. Agent pod output (what the runtime and your own agent code print) is kept for 30 days. If your agent code prints message text, that text is in those logs for 30 days. API request logs currently have no expiry; a retention policy for them is not yet set.
The model provider. When your app runs on Guuey’s managed model access with Claude, the default, each turn goes to Anthropic through Guuey’s own Anthropic organization. That organization is on Anthropic’s standard API data retention, with no zero-data-retention arrangement, so Anthropic keeps inputs and outputs as its commercial data retention policy describes. Development Partner Mode, Anthropic’s opt-in setting that lets it train its models on submitted data (Anthropic’s service terms), is off for that organization, so Guuey has not given Anthropic that permission for your app’s turns. Guuey sets no inference_geo of its own, so a call that doesn’t set one follows the default of the Anthropic workspace Guuey uses, which is global routing: on Claude 4.6 and later models, inference may run in any available geography, and the data Anthropic stores at rest stays in the US (Anthropic’s data residency). If your app brings its own model key (BYOK), the provider account is your own, and its retention and routing are that account’s settings.
How it is deleted. Every path below removes the thread and every message in it; none of them hides a thread and keeps it.
| Who | What they can do |
|---|---|
| A guest | Clear in the embedded chat deletes the conversation on the server and starts a new one under a new guest identity. The button shows for a guest with a conversation to clear. |
| A signed-in end user | Can delete their own thread through the same endpoint, DELETE /v1/threads/<threadId>, when your app offers it (clearConversation() in @guuey/chat calls it). The embedded chat and the Guuey app (Portal) have no per-thread delete button. A Guuey account holder who deletes their account in Portal loses every thread across every app, about 30 days after the request; they can cancel before then. Portal’s Delete memory clears what agents remember about them, not their threads. |
| Your app, for one end user | guuey apps byo-user erase <appId> --sub <sub> deletes that user’s threads, messages and sessions in the app straight away, and queues the wipe of their memory files (done within about 15 minutes; --status reports it). Same thing over HTTP: POST /v1/apps/<appId>/byo-users/erase with { "sub": "<sub>" } returns 202 with { wipeId, status }, and GET /v1/apps/<appId>/byo-users/erase-status?sub=<sub> returns the wipe’s status (queued, done, or none). |
| Your app, all of it | Deleting the app deletes every thread in it once its 30-day restore window has passed. |
Who can use the per-user erase, and how it behaves:
--suband thebyo-usersroutes name the user by thesubyour own sign-in issues, so they work for an app in identified mode (userAuthMode: "byo"). To erase any end user, a guest or a Guuey account holder included, name them by their Guuey end-user id instead (thesubof the token your app’s servers receive from Guuey:byo_…,g_…, or an account id):POST /v1/apps/<appId>/end-users/erasewith{ "userId": "<id>" }, andGET /v1/apps/<appId>/end-users/erase-status?userId=<id>for its status. Abyo_…id names the same erase as itssub.- For an app owned by a workspace, it needs that workspace. That means a personal access token (
guuey_user_…) with themanagescope, or a console session, belonging to an owner or admin of that workspace, or a workspace API key (guuey_wkz_…) of that workspace, so an automated account-deletion job can call it with the workspace key. Polling an erase’s status (--status, or theerase-statusroutes) also works with a read-only personal access token. A key from another workspace gets the same404as an unknown app. A workspace key stops working once the owner or admin who created it, or who later took it over, loses that role (workspace API keys). An app service token (guuey_svc_…) is refused. - For a personal app, only its owner can erase, with their own personal access token or console session. A workspace API key, or any other person’s token, gets the same
404as an unknown app. An app service token is refused with403. - When the refusal is about the app or whether the caller is in its workspace, the answer is
404, the same as for an app that does not exist: another workspace’s app, someone else’s personal app, or someone with no membership there. A member of the workspace below admin gets403, as does a personal access token without themanagescope sending the erase or the export. - To run it from CI, put the workspace key in the
GUUEY_API_KEYenvironment variable and callguuey apps byo-user erase(or the HTTP route) as usual. The export below cannot run that way. It needs a person. - It also works on an app that is archived, suspended, or waiting to be deleted. An erasure request has to be honoured whatever state the app is in.
- Every accepted erase writes an entry to the audit log before it changes anything: before the memory wipe is queued and before anything is deleted. The entry names the app, the end user’s Guuey id (
byo_…derived from thesub, or the id you sent) and who sent the request (a person, or the workspace key’s id). It never contains thesubyou sent. If that entry cannot be written, the request fails and nothing is queued or deleted. Send it again. - The same caller re-sending while the first erase is in progress adds no second entry. A later erase (after the first one is done), or a different caller, gets its own entry. If a request fails after its entry was written, sending it again can add a second entry for the same erase, and so can two requests sent at the same moment. An erase never runs without one.
Exporting one end user’s conversations. To answer an end user’s request for a copy of their data, read their conversations in your app. This works for an app in identified mode (userAuthMode: "byo"), naming the user by their sub. Any other app answers 400, and there is no export by Guuey end-user id yet:
GET /v1/apps/<appId>/byo-users/threads?sub=<sub>lists that user’s threads in the app, newest first.GET /v1/apps/<appId>/byo-users/threads/<threadId>/messages?sub=<sub>returns one thread’s messages in order.
Call the two routes over HTTP with a personal access token that has the manage scope, or from a console session.
Both routes return pages: pass nextCursor back as ?cursor= until it is null. A page can hold fewer rows than limit, or none, while nextCursor is still set: a list page because other apps’ threads are skipped, a messages page because sealed messages are withheld. limit is optional. A value that is not a whole number from 1 to the maximum (100 threads, 500 messages) is refused with 400. The rows have the same fields as the conversation reader in the console, with no internal message content. Unlike that reader, messages of a sealed part of a thread are left out entirely (sealedWithheld counts them on each page). The export covers conversation transcripts only: threads and their messages. It does not include sessions, snapshots, media, or memory and other files. It needs a person: a personal access token with the manage scope, or a console session, of someone the erase would accept (an owner or admin of the app’s workspace, or a personal app’s owner). Unlike the erase, it refuses a workspace API key, and an app service token is refused too. Each page it serves is also recorded in the audit log under the end user’s Guuey id (byo_…), never the sub you sent. That record is best-effort: unlike the erase’s entry, a failed audit write does not stop the page.
What Guuey keeps out of reach
Section titled “What Guuey keeps out of reach”A short list worth stating plainly:
- Your users’ third-party passwords — OAuth happens at the provider; only tokens ever reach Guuey.
- Third-party OAuth tokens — never in your agent’s pod, plaintext only inside the gateway during a forward.
- Hosted-MCP secret values — write-only from your side; no API returns them.
- Managed model keys — by design, not placed in the environment Guuey gives your agent’s code.
- Other tenants — not reachable from your pod’s network, filesystem, or identity, and yours not from theirs.
Your app’s own environment variables, including the ones under Secrets, are not on this list. Secrets are sealed at rest and no API returns their values, but your colocated MCP servers receive them as plaintext environment variables (the custody table).
Isolation claims on this page describe the running platform. If you’re evaluating Guuey for a workload with specific security requirements, the runtime details above are the right starting point — and the same isolation applies to the hardest case, compute-class MCP servers, because that is what the platform was built to host.