New Persistent assistants now work in governed, cross-host teams. See what changed
Security architecture

Security, with the
trust boundaries shown.

Code stays where it runs. Classified free-text content crosses the relay as ciphertext; routing fields remain visible, and password seats and Enterprise SSO use different key-delivery trust models.

Last updated
Model
Local execution · encrypted control
AES-256-GCMContent encryption
600,000Password-path PBKDF2 iterations
12-byteRandom nonce per message
Two pathsClient-wrapped · KMS-backed SSO
Our security model

Encrypt the control path. Make every key path explicit.

Glueprint separates execution, encrypted transport, key delivery, and authorization. Password and recovery seats keep usable key unwrap on authorized clients; Enterprise SSO deliberately places the active relay and AWS KMS inside the key-delivery trust boundary.

01 · Local execution

Repositories stay on your hosts.

Agent processes, terminals, editors, and project files run on the laptop, workstation, server, or daemon host you selected.

02 · Encrypted transport

Free text crosses the relay as ciphertext.

Clients encrypt classified content before relay transit. The way clients obtain the tenant key depends on their authentication path.

03 · Explicit authorization

Membership is not implied by encryption.

Server-side checks enforce host visibility, team membership, roles, and object permissions on applicable request and delivery paths.

Encrypted control path

Where plaintext can live.

Password seats unwrap on clients. Enterprise SSO sessions receive a KMS-unwrapped tenant key over TLS, placing the active relay inside that key-delivery boundary.

Your hostsRepositories · agents · PTYs
plaintext while in use
Encrypted
Glueprint relayCiphertext · routing · presence
SSO key delivery via KMS
Encrypted
Your screensDesktop · portal · mobile
plaintext after authorization
Password: client-side unwrapSSO: KMS-backed relay unwrapVisible: tenant and routing identifiersProviders remain a separate boundary

Glueprint uses a tenant Data Encryption Key (DEK) for relay content. Password, recovery, and agent-host paths store and transport only wrapped key material. Enterprise SSO stores a second KMS-wrapped key and permits the relay to call AWS KMS Decrypt for an authenticated SSO session.

ContentAES-256-GCM

Authenticated encryption protects confidentiality and detects ciphertext modification.

Nonce12 random bytes

Every encrypted message generates a fresh nonce for GCM nonce uniqueness.

Password seatsPBKDF2 + AES-GCM

A password-derived KEK unwraps the tenant DEK on the client.

Agent hostsPBKDF2 + AES-KW

An API-key-derived KEK unwraps the tenant DEK on the host.

Enterprise SSOTenant CMK + TLS

AWS KMS unwraps a tenant-bound key; the relay returns its bytes to the authenticated client over TLS.

Portal cacheScoped session storage

Raw DEK bytes may be cached per tab under a user-and-tenant scope so a reload can recover the active key.

The desktop keeps its active DEK in zeroizing process memory and clears it when the encryption manager locks. The portal may keep exportable key bytes in tab-scoped session storage until logout or the browser session ends. Device compromise can expose plaintext or key material available on that endpoint.

Content encryption narrows plaintext exposure, but the exact relay boundary depends on the authentication path. It is not a promise that every field is opaque, and it is not a substitute for endpoint security or intra-organization access control.

Password & recovery seatsThe relay stores a wrapped tenant DEK and does not receive the credential-derived KEK. A database or relay compromise alone does not provide the client-unwrapped key.
Enterprise SSO seatsThe relay can ask AWS KMS to decrypt the tenant-bound SSO key and returns it over TLS. An active relay compromise is therefore inside this trust boundary; a database snapshot alone remains insufficient.
Visible for routingTenant, host, session, assistant or team identifiers; presence; sequence numbers; timestamps; event labels; and selected fixed-enum/read controls.
Visible on endpointsAuthorized clients and hosts decrypt content to display or execute it. A compromised endpoint can expose plaintext available there.
Visible to AI providersThe coding agent and model provider you configure receive prompts and context directly under their own security and privacy terms.
Inside the organizationThe tenant DEK is not a per-user access boundary. Server-side visibility and membership checks gate delivery.

Human and agent connections use separate credential types and scopes. Desktop sign-in uses PKCE, human relay clients use JWTs, and agent hosts authenticate with API keys.

DesktopPKCE + local credential files

User tokens and API keys are kept in separate files under the Glueprint data root; Unix writes use owner-only permissions.

Human clientsJWT and refresh controls

Email verification, optional MFA, rotation, and refresh-family revocation reduce account-token risk.

Agent hostsScoped API keys

Activation binds the connection to an organization and host identity; an environment-variable override is also supported.

EnterpriseSAML, OIDC, and SCIM 2.0

Claimed domains, identity-provider login, and lifecycle provisioning support managed access.

Server-side authorization evaluates organization role, host visibility, team membership, board role, and object ownership before data or control requests are accepted. Sensitive WebSocket controls pass through explicit subtype allowlists and role gates.

  • Team mutations remain server-authoritative, including lead and tenant-admin checks.
  • Board actions distinguish viewer, contributor, and lead permissions.
  • Assistant governance adds permission tiers, tool filters, budgets, quiet hours, and supervision rules.
  • Task Flow Definitions restrict state transitions by role.
  • Audit events record security-sensitive account, team, task, and administrative activity.

Repositories, agent processes, terminals, and the primary operational store remain on the selected host. Desktop and daemon data default to ~/.glueprint/, with YAML and JSONL files for configuration and event history.

Rust services expose typed command boundaries to the desktop frontend, and shared storage paths use atomic-write patterns where implemented. Tokens, API keys, and managed harness keys use dedicated local files rather than universal OS-keychain storage; Unix writes use owner-only permissions. Endpoint account controls, filesystem permissions, and disk protection remain part of the security boundary.

Authenticated HTTP and WebSocket connections carry control and encrypted event traffic. Sequence tracking and gap fill support ordered delivery and recovery; they are delivery controls rather than a replacement for cryptographic authentication.

  • Control-plane and data-plane roles separate account/billing operations from relay traffic.
  • Every tenant is pinned to a cluster, and mismatched HTTP or WebSocket connections are rejected with a re-home target.
  • Rate limits and heartbeat monitoring reduce abuse and stale connections.
  • PostgreSQL stores durable service state; Redis supports presence, routing, and short-lived buffers.
  • Typed control messages, structured errors, and explicit allowlists narrow the remote-command surface.

Glueprint does not claim a certification, penetration-test result, or security property that has not been independently established.

We welcome responsible reports. Send a private description, potential impact, reproduction steps, affected version or surface, and relevant proof-of-concept material to security@glueprint.ai. Please avoid accessing data that is not yours or disrupting other users.

We will acknowledge and assess reports as promptly as practical, coordinate remediation, and ask that you allow reasonable time before public disclosure. If an incident affects personal data, we will investigate, contain it, and notify affected people and authorities as required by applicable law.

Responsible disclosure

Found something we should investigate?

Report it privately with enough detail to reproduce the issue. Do not include credentials or personal data in the first message.

security@glueprint.ai