Security architecture
How Laze encrypts workspace data, keeps keys from agents, isolates computers and controls staff access and deploys.
Laze keeps every workspace in the European Union and encrypts its content under a key that belongs to that workspace alone. Agents work on isolated computers and reach keys through a vault that decides every use. Our own staff and our deploys pass through the same kind of control: short-lived access, passkey approvals and a record of each step.
- Hosted in the EU. Servers, the database, files, the vault and agent computers run in Paris, France. Encrypted backups are kept in Amsterdam, the Netherlands.
- A key for each workspace. Content is sealed with AES-256-GCM under a data key of the workspace's own.
- Master keys off our servers. The keys that protect those data keys are held in Scaleway Key Manager. Every use goes through small functions that log each call where our servers cannot change it, and a watchdog disables the vault key on unusual use.
- A vault between agents and keys. Each key has a level, from automatic use up to a person approving every use on their own device. On a Laze computer an agent holds placeholders for its API keys, and the real key is added to a request only on its way to a site approved for that key.
- Isolated agent computers. Each person's agents run in their own Firecracker microVM, which reaches the internet only through a proxy.
- Narrow staff access. Staff do not browse workspaces. A support visit lasts at most an hour and is recorded in the workspace's audit log, reading content in an incident needs a second staff member's passkey, and agents reach staff actions only through passkey-approved keys that expire within the hour. Each step lands in the workspace's own audit log.
- Controlled change. Every change is tested on the exact code that ships, and changes to security-sensitive code deploy only with a signed approval that the production host checks.
The sections below describe each control in detail, for the security engineer who signs Laze off.
We publish this design because we believe transparency and public scrutiny are the best way to hold our systems to the level of security we aim for. If you have questions, or see a way to make the design stricter, please write to security@laze.so.
Hosting and data residency
Laze runs in the European Union. Application servers, the database, file storage, the vault and agent computers run on Scaleway in Paris, France. Backups are stored with Scaleway in Amsterdam, the Netherlands, and are encrypted before they leave the server. Reasoning Engine B.V., a Dutch company, operates Laze.
Every company that processes personal data for Laze is listed on the subprocessors page, with what it receives, where, and under which transfer mechanism. That page also lists the services a workspace connects itself, which process data under their own terms.
Data in transit
Every public Laze address is served over HTTPS only, with TLS 1.2 as the minimum and TLS 1.3 available. Cloudflare terminates TLS at the edge and connects to our origin with full certificate validation. The origin firewall accepts web traffic only from Cloudflare's published address ranges.
The database has no public endpoint: it is reachable only on a private network. When we promote a replica to primary, its access list is replaced, so a new instance never keeps the provider's default rule that allows every address. Redis requires a password. Agent computers reach the application over a dedicated listener on the host and do not pass through Cloudflare.
Data at rest
Workspace content is sealed with envelope encryption, so that a copy of the database, a backup or a disk snapshot on its own shows no workspace content:
- Each workspace has its own AES-256 data key.
- Data keys are stored only in wrapped form, encrypted under a content master key held in Scaleway Key Manager. Wrapping and unwrapping happen inside Key Manager.
- Each item is sealed with AES-256-GCM. The associated data binds the ciphertext to its workspace, table row and column, so a ciphertext copied to another row or workspace fails to open.
- Each data key is also wrapped to an offline recovery key kept outside Scaleway, so content survives the loss of the provider account.
The application opens content when it shows it to a member, searches it or hands it to an agent, and it never holds a master key. Sealing and opening happen in a separate decrypt process on the host. The application asks it over a local socket, and the process checks which service unit is calling before it answers. Unwrapped data keys live only in that process's memory, for a limited time, and every open is counted.
Vault secrets use the same scheme under their own master key, which was generated inside Key Manager and cannot be exported.
Content sealed this way includes chat messages and threads, drafts and scheduled messages, attachment text, file contents, feed cards, notifications and push texts, agent inboxes, memory and wiki pages with every saved version, link previews, schedule prompts, the event log's payloads, queued job bodies, app preview images and the vault's audit text. Plaintext from before sealing was removed from the database after each group was verified. Event log payloads are compressed before they are sealed, except the vault's own events, which stay uncompressed so a secret never shares a compressed block with text someone else chose.
File contents are sealed per file: each file has its own random key, sealed under the workspace key, and is stored as authenticated chunks bound to the workspace, file and chunk position. App databases and their backups are sealed the same way. Database backups are encrypted with their own key, separate from the storage credentials.
Keys outside the application
The master keys are used only through small serverless functions outside the application host. Each function is the only holder of the credential that may encrypt or decrypt with its key, and logs every call to Scaleway's logging service, which the application host cannot change. A watchdog outside the host reads those records on a schedule. When unwraps of the vault key rise above a learned baseline, it disables the key, which is reversible and never a deletion, and alerts us by email and in Laze.
The decrypt process also counts opens per workspace and in total. Bursts raise alerts, and for vault keys a burst locks every open until an operator resets it with a hardware-backed passkey. Each alert names the uses and the code paths that drove the burst, and operators read alerts through an audited function, without access to the host.
On 13 November 2026 this lock tripped on our own code. To build placeholders, each start of a hosted agent opened every key its owner held, and an owner with several hundred keys passed the ceiling. Every key held on the server stayed locked until an operator reset the breaker with the passkey. Starts now open each key once per process, paced well under the ceiling, and a key used through the proxy is opened at most once a minute.
Search over encrypted messages
The database keeps no words. Each word of a message, its short prefixes and each pair of adjacent words are stored as keyed HMAC tokens under a search key specific to the workspace. A query is hashed the same way and matched against the tokens; exact phrases are checked after decryption.
The tokens reveal no words, cannot be linked across workspaces and cannot open a message. What they show a database reader is which messages in one workspace share a word or a word pair, and how often.
Sessions and sign-in
Session tokens, API keys, invite and device tokens are stored only as SHA-256 hashes, so a database copy cannot sign anyone in. Google and Apple sign-in tokens are sealed under a platform key with the same envelope scheme. A session lasts seven days from its last use. A password account cannot sign in until its email address is confirmed.
On the device
Pages the web app keeps for a fast start are stored in the browser's IndexedDB sealed with AES-GCM, under a key that is imported non-extractable and that a copy of our database alone cannot rebuild. Signing out, session expiry and revocation delete it. Approval cards and anything naming a vault key are never cached on the device.
The vault
Agents ask the vault for a key or connected account by name. The vault decides from the key's level, the person the agent works for and the conversation. Each key has one of four levels:
| Level | What happens when an agent asks | Storage |
|---|---|---|
| Allow | The agent uses it | Envelope encryption on the server |
| Auto | An automatic check reads the request and allows it, or asks a person when unsure | Envelope encryption on the server |
| Always ask | A person approves each use | Sealed to the owner's devices |
| Human only | Agents never use it | Sealed to the owner's devices |
Sealed to a device
Always ask and Human only keys use two-lock encryption. The value is encrypted to the owner's device key, a P-256 key whose private half is wrapped under the output of a passkey's PRF extension, or kept in the Secure Enclave on Apple devices. The server stores only ciphertext it cannot open, so approving on the device is the act of decryption.
A person's first device in Laze is active at once. Every later device waits until one of her active devices approves it with its own signature, so a stolen session cannot enrol a device of its own. Each enrolment, approval and re-authentication challenge is single use. iPhone enrolment also carries an App Attest attestation checked against Apple's root. Removing a device ends every lease it approved.
Keys that must stay on the server, such as OAuth logins used through the proxy, can turn on "Approve on a device": every approval on that key then needs a fresh passkey, Touch ID or Face ID proof, never a password or a plain tap.
Approvals and leases
An approval covers one use, or a lease of at most seven days, two by default. Lowering a key's level or lengthening a lease happens only on the Vault or Connectors page, and from Always ask or Human only it also takes a device proof. The CLI, the API and agents can only raise protection. Only the people the vault names for a key decide its requests, never an agent. Some actions always ask a person whatever the level, such as sending email or messages outside the company. A new connection starts at its connector's tier: Always ask for mail, private files, payments and sending to an audience, Auto for tools such as calendars and code hosts, and Allow for low-risk ones. A workspace admin can enforce a tier's level as a floor that members can raise but not lower.
The automatic check for Auto keys sends the request, the key's rules and the recent conversation of that turn, never a key value, to OpenAI, which is listed on the subprocessors page. It goes through the LangWatch AI gateway to OpenAI's servers in the United States. It moves to OpenAI's EU servers by 1 December 2026; that waits on OpenAI turning on EU data residency for our account. If the check fails or times out, a person decides.
What agents see
On a Laze computer, an API key used over HTTPS never enters the computer. The agent holds a placeholder, and the egress proxy swaps in the real value on the way to a site approved for that key; Keys at the egress boundary describes how. An agent starts with no key at all and asks for one by name with laze vault run or laze vault env. When a command needs the real value, such as a signing key or a database password, the vault checks that one request and gives the value only to that command. Values that appear in chat or logs are masked.
Keys an agent made
Agents cannot add keys to the vault. When an agent makes a credential for its owner, such as a token it created on a service's settings page, it offers it with laze vault offer, which reads the value once from standard input. The vault seals it and the owner gets a card naming the key, the field, the level and the reason, never the value. Only the owner's approval saves it, to their personal keychain, at Always ask unless the agent proposed a lower level. Sharing it with someone else then needs the owner's passkey. A denied or unanswered offer is deleted.
Agent session files
Coding agents keep a session file of what they saw. If a command printed a vault value, the value would stay in that file on disk. Laze replaces each vault value it finds there with a reference such as {{vault:openai}}:
- on a Laze computer, at the end of each turn, in Claude Code sessions and the Codex sessions imported to the computer;
- on a person's own machine, through the Laze plugin for Claude Code, which sends the new lines of its own session at each stop and writes the answer back in place.
Only exact values the vault holds and the agent may use are replaced. There is no guessing by pattern, so a secret the agent generated itself stays as written, and nothing outside the session folders is touched. Known gap: on a person's own machine the lines are matched as stored, so a value with a character JSON escapes, such as a quote, a backslash or a line break, is not found, and a line over 64,000 characters is skipped.
Anything derived from a secret, such as a match, a key name, a count or an error difference, is treated as the secret itself and checked against the reader's access before it is shown.
Audit trail
Every vault use, approval, reveal, share, level change and device change is written to the key's usage log, with who asked, who approved and how. Entries form a hash chain whose stamps cover a keyed digest of each entry, so a database reader can neither read an entry nor test a guess against its stamp. A scheduled check rehashes every chain, and a break raises an urgent alert.
Keys at the egress boundary
Status: live since 13 November 2026 for agents on Laze computers. Agents connected from a person's own machine are unchanged and use laze vault run.
Placeholders
When an agent asks for an API key with laze vault run or laze vault env, its computer gets a placeholder for each field instead of the value. The computer holds none before it asks, and asking again gives the same placeholder. A placeholder has the value's length, the same kind of character in each position and the same leading prefix, such as sk-, so libraries that check a key's format accept it. The rest is random, different for each agent and computer. Values under 20 characters get no placeholder.
All traffic from the computer leaves through its egress proxy, which terminates TLS with a Laze certificate the computer trusts. The proxy looks for the agent's placeholders in headers, credentials, the URL and text bodies. When it finds one on its way to a site approved for that key, it asks the vault, which decides the use like any other: the key's level, the agent's grant or lease, the automatic check, a person when needed. Then the proxy writes the real value into the request. Each request is decided and logged on its own. The value is opened at most once a minute per key and kept only in the application's memory for that minute.
The proxy also:
- puts the placeholder back if the site echoes the value in its answer, also when the answer is encoded or compressed;
- never follows a redirect, so a value cannot be carried to a site no one approved;
- refuses a placeholder in plain HTTP, in a binary body or in a raw connection that is not HTTP;
- swaps only while the agent's turn runs, and fails closed when it cannot reach the vault.
Each key has its own list of sites
A site is an exact host name and port, with no wildcards. A key's page in the vault lists its approved sites, with who or what approved each one and when. The people who answer the key's cards can add a site there or remove one. Agents cannot change the list.
When an agent sends a placeholder to a site that is not on the list, the proxy holds the request and the vault checks the site. If the check does not approve it, the key's owner, or a workspace key's managers, get a card with three buttons: Allow once, Always for this site and Deny. Always for this site adds the site to the key's list until a person removes it. Deny refuses the request, and the agent's error names who denied it. A held request waits up to 60 seconds; after that the agent is told to retry once the person answers. The card stays open for a day, so a later approval lets the retry through.
How a new site is checked
The check reads the key's name and label, the site, its registrable domain, the domain's age from public RDAP records, and the sites the key already uses. It never sees the value, the placeholder or the request. There is no list of vendors. A model answers four short questions: does the site belong to the service that issued the key, is it an official domain of the service the key names, is the key for the workspace's own systems, and does the site look like a lookalike. The vault decides from the model's probabilities:
- A key's first site always asks a person. In our tests no input told a real first site apart from a well-made lookalike.
- After that, a site on a domain the key already uses is approved when the model is at least 90% sure it belongs to the key's service and the site does not score as a lookalike.
- The check never rejects. A high lookalike score adds the line "This site may be imitating another one" to the person's card.
- A check that is off, slow or fails asks a person. A busy model endpoint is tried again within the check's time limit.
- In progress: approving a key for the workspace's own systems on the workspace's verified domains. The rule is built; the vault does not pass those domains to it yet.
We measured the check before turning it on, with gpt-6-luna through the LangWatch AI gateway, the path production uses:
| Dataset | Pairs |
|---|---|
| Real keys and the sites they were used with | 71 |
| Lookalike sites used to tune the rule | 100 |
| Lookalike sites held out from tuning, from dnstwist permutations and the OpenPhish and Phishing.Database feeds | 94 |
With the final rule the check approved 0 lookalikes and rejected 0 real sites. It approved 18 of 50 later sites of a key's own service; the rest asked a person. Rejecting stays off until the model rejects at least 80% of the held-out lookalikes while rejecting no real site. Today it rejects 64%.
The check runs on OpenAI's Decisions API, reached through the LangWatch AI gateway, which sends it to OpenAI's servers in the United States. It moves to OpenAI's EU servers by 1 December 2026; that waits on OpenAI turning on EU data residency for our account. The check never sends a key value.
What the swap does not cover
We replayed our own team's real key use, about 51,600 uses by people and agents, against this design, reading names, hosts and request shapes, never values. Leaving out two one-off bursts, about 80% of uses fit the swap: a key sent over HTTPS to its own service, or to a site approved once. About 19% need the real value inside a program:
- AWS and other S3 keys, which sign requests on the machine (SigV4);
- database URLs and passwords, and SSH keys, which do not travel over HTTPS;
- signing and encryption keys used inside a program.
For these the agent asks with laze vault run --real-value. The vault's automatic check reads the key's label and rules, the command and what the person asked the agent to do. A clear use, such as a database query or signing a release, gets the value in that one command. An unclear one goes to the key's owner. A command that would print, copy or send the key is refused. Keys set to always ask still ask. In our test set of 64 requests, 23 of them held out from tuning, the check let 86% of clear uses through, refused none of them, and let no unclear or exposing request through.
A key with a short field, such as a host name or a region, keeps a placeholder for its secret and gives only the short field's value.
A key's owner can mark it as used on the computer only, so it is never swapped. Keys sealed to a person's devices and Human only keys are not swapped yet. A client that pins its own certificates cannot use the swap and gets a hint to use laze vault run. An agent can still use a key at a site it is approved for, within the key's level and budgets, and a site that stores what it receives could store the key: approving a site means trusting it with the key.
Agent isolation
Each person's computer is its own Firecracker microVM, started under the Firecracker jailer with its own user, chroot and cgroup. A computer has its own disk; the base image is shared read-only. Computers have no route to each other, no DNS and no NAT: the firewall lets a computer reach only its egress proxy. The proxy cannot reach the database, private networks or the host itself, except the Laze API. A workspace's computers share one /work folder for handing files between agents.
A computer is one trust zone for its owner's agents, which is why keys live in the vault and not on disk.
When a person turns on a dedicated IP, every page their computer's browser opens leaves through that address, sign-ins to model providers included, so a site never sees one sign-in from two addresses. The browser never falls back to the shared address: if the dedicated address cannot reach a site, the page fails and the browser tab says so. Only Laze's own addresses leave from the shared one. A change to the setting reaches a running browser at once.
What an agent may read comes from its signed turn, not from what its client claims. In a turn, an agent reads the conversation it answers and what the person who started the turn may read. A turn token stops reading chat and memory when the turn ends. A person's private memory lines load only on a personal agent that person owns.
CLI keys
A key made by laze login is bound to a key pair on its machine. Every call carries a signed proof over the method, path, time, a one-time id and the token's hash, so a copied token alone is refused and its owner is told. Each key needs its owner's passkey again every seven days. A burst of reads, or use from a network the key has not been seen on, raises a card for its owner, and a burst revokes the key on the spot.
Connected agents
A coding agent connected from a person's own machine is known by its session id alone. The folder it runs in never decides which agent a session speaks as, so another session opened in the same folder stays silent until its person binds it. Only a person moves an agent to a different session; the server refuses a session that tries to take an agent over on its own.
Apps
Apps run on their own registrable domain, separate from Laze, with a host-only session cookie and a data API that answers only its own origin. An app's scripts cannot reach a Laze session or another app.
Our own access
No database role reads content: to every role, the table owner included, content is ciphertext. The application connects with roles limited to reading and writing rows; a separate role owns the schema and runs migrations. The read-only role our engineers use for diagnostics reads ids, states, counts and timestamps, but not content, secrets or personal data such as names and email addresses, and every session must state a reason. A monitor raises an alert for any unknown database session, role or access rule.
Staff do not browse workspaces. The access staff hold:
- Operations view and management. Staff can list workspaces and see members, billing and recent audit rows. Staff with management rights can view Laze as a person for up to an hour, with a stated reason, to investigate a support case. Every such visit is recorded in the audit log of each workspace the person is in A visit cannot mint credentials or act in the vault.
- Break-glass content reads. In an incident, a staff member asks to read one conversation over at most seven days, or a short list of messages, with a reason and a time limit. A second staff member must approve with a passkey or Secure Enclave signature from their own device; a password never counts and the requester cannot approve. Every page read is counted, and every step lands in the workspace's own audit log.
- Operator keys. A single operations action on a single target, requested with a reason, runs only after an operator approves it with the operator passkey. The approval lasts an hour and binds to the requesting key. Grants, impersonation, break-glass, the breakers and the keys themselves can never be reached this way.
- Operator passkeys. Resetting a breaker or overriding the watchdog needs the operator passkey. A new operator passkey is added only by a record signed by a current one; the chain of records is replayed by the watchdog outside the host, which emails every change.
Production hosts accept SSH keys only, from one deploy host only. Root access needs a separate key that is released only after an approval each time it is used. Root logins, refused commands and configuration changed outside a deploy raise alerts.
Change control
Every change to Laze lands through automated gates: format, lint, type checks, unit, architecture and integration tests run on the exact tree that is pushed, before it deploys. Each deploy is followed by a smoke test against production.
Changes to sensitive paths, including deploy and gate machinery, CI workflows, the firewall, the decrypt process, content sealing and authentication, deploy only after a named approver signs off. The approval releases an Ed25519 key that signs a digest of the sensitive files. The production host checks that signature against the list and public key of the release already live, so a change cannot approve itself or remove itself from the list.
CI actions are pinned by commit SHA and container images by digest, and a test fails the gates on an unpinned one. Production secrets live in Scaleway Secret Manager, and the host holds only a read-only credential to fetch them at deploy. Outside production, the credentials that can read user data, such as database and backup keys, need an approval each time an engineer uses them.
Logging and monitoring
Message bodies, drafts, memory, prompts and file text never go to logs, metrics, errors or event payloads; logs carry ids and lengths. Stored audit arguments keep the size of free text, not the text. The production host keeps its system logs for at most fourteen days.
Alerts from the decrypt process, the key watchdog, the audit chain and the database monitor become urgent cards, with push, for the operators on call. The watchdog also sends email through a path that does not depend on the application host.
The database monitor also reads the database's disk and status from the provider. It warns at 70% full and pages at 85%, or when the database is not ready. A page reaches the operators by email, sent without the database, and as an urgent card in Laze.
Retention
| Data | How long | Status |
|---|---|---|
| Workspace audit log | 1 year, then deleted by a daily pass | Live |
| Event log | 90 days; 14 days for routine notices such as delivery and wake steps; the vault's alert history is kept | In progress |
| Mirrored Slack, Discord and WhatsApp messages | A cache, deleted 7 days after the last read, as below | In progress |
| Database backups | 6 months, encrypted | Live |
| Provider database snapshots | 7 days | Live |
| Production host system logs | 14 days | Live |
Laze keeps mirrored messages only as a cache. A mirrored Slack, Discord or WhatsApp message is deleted 7 days after it arrived or was last read in Laze, whichever is later. When someone scrolls back past the cache, Laze reads the messages again from the source. For WhatsApp the source is the person's own computer, which keeps 6 months of history, encrypted. Agents read older messages back the same way, and each of those reads is recorded in the audit log. Messages written in Laze are kept for as long as the workspace exists. Until this ships, Slack and Discord keep a rolling 7-day cache that an admin can set from 1 to 30 days, and WhatsApp keeps 7 days.
Incident response
When an alert fires, we contain first: a tripped breaker stops decrypts, the watchdog can disable the vault's master key, and sessions and credentials can be revoked. Data keys and the master key can be rotated by rewrapping, and old generations stay readable until the move is verified.
If a breach affects personal data for which we are the controller, we report it to the Dutch Data Protection Authority within 72 hours where the GDPR requires it, and tell the people affected without undue delay when it is likely to put their rights at high risk. If it affects workspace content, we tell the workspace's owners without undue delay, with what they need to meet their own obligations. See the privacy policy.
Reporting a vulnerability
Found a security issue? Email security@laze.so. The same address is in our security.txt.