Security

Last updated November 20, 2026

How we protect workspace data, handle AI requests and run coding machines. The sections below describe our controls, certification status and data commitments.

1. Compliance programme

Formal certification is our highest compliance priority, and the control work it rests on is already implemented and enforced in code rather than described in a policy document. The sections below are that programme: tenant isolation proven by automated tests, credential handling designed so that no shared secret reaches an untrusted process, a gated supply chain, a recurring adversarial audit cycle, and a watch that alerts us when we are attacked.

Our SOC 2 Type II observation period began on 15 November 2026. Over that period an independent auditor tests how our controls actually operate - every production release, access change, vulnerability and backup it samples - rather than how they are written down. No report has been issued yet, and we will not describe ourselves as certified before an auditor has issued one - when that happens, it will be published here. If certification status is a gating requirement for your review, contact [email protected] and we will tell you precisely where the programme stands and the timeline we are working to.

Controls in place today

Tenant isolation
Enforced in Postgres by row-level security, with regression tests that fail the build if a policy weakens.
Encryption
TLS in transit. The workspace database and its backups are held in the EU, encrypted at rest. Stored credentials encrypted with AES-GCM under a key held outside the database.
Access control
Passwordless sign-in, and SAML single sign-on on Enterprise. Two-factor, enforceable team-wide and checked by the database on every read. Administrator, billing, member and read-only viewer roles.
AI data
Every model we pick runs with zero data retention, secrets are hidden before a request leaves our servers, and no customer content trains a model.
Change management
Every production change is a signed commit in a pull request approved by someone other than its author, and only CI deploys it.
Monitoring
A security watch reads database, GitHub and Cloudflare logs as they arrive and alerts the team to signs of attack.
Testing and auditing
Recurring AI-driven audits of the whole codebase and an internal penetration test. Every confirmed finding becomes a regression test.
Supply chain
Secret scanning, static analysis and malicious-package checks on every change. New package releases wait 7 days, and build steps are hash-pinned.
Data portability
Full workspace export on every plan, with a contractual 60-day wind-down commitment.

Framework status

SOC 2 Type II In progress
The observation period began on 15 November 2026: an independent auditor is testing how our controls operate across it. No report has been issued yet; we will publish it when it has.
ISO/IEC 27001 Under evaluation
Its control requirements overlap substantially with the SOC 2 work above. No certificate has been issued.
GDPR Supported
Data Processing Agreement incorporated into the Terms, so it is in force for every customer with nothing to sign; a copy on request. Sub-processors published, a data protection impact assessment for AI processing, analytics processed in the EU, no session replay.
HIPAA Not supported
WeMachines is not a business associate and does not offer a BAA. Protected health information must not be stored in a workspace.

We complete customer security questionnaires, and our Data Processing Agreement forms part of the Terms, so it already applies to your workspace rather than waiting on a request. A copy, countersigned if you need one, is available at [email protected].

Our Trust Center shows this programme as it runs: the controls Vanta monitors continuously, the sub-processors that handle your data and where they process it, and our security policies, which you can request there.

2. Continuous auditing, testing & monitoring

WeMachines' architecture and codebase are audited on a recurring basis using frontier AI models, directed adversarially at our own system: instructed to defeat tenant isolation, to escalate a standard member to administrator capability, to reach another workspace's data, and to extract credentials from the environments that hold them. Because the audit is automated, it runs against the whole codebase rather than a sample, and it is repeated as the product changes rather than once a year.

A finding is not considered closed when the code is fixed. Every confirmed issue is remediated and then converted into an automated regression test that fails the build if the defect is ever reintroduced, so the security posture ratchets in one direction only. Claimed findings are verified against a live database before being accepted, because an analysis that reads plausible in the abstract is not evidence of a vulnerability, and a control that depends on someone remembering it is not a control.

In November 2026 we also ran an internal penetration test against the database and its policies, file storage, real-time channels, the apps a workspace builds, the coding runner, the AI tools and the desktop app. It found no way from one team's data into another's. Its findings were fixed within days or scheduled, each with the same regression test behind it, among them a script policy the app now enforces, MCP connections a person can revoke, and stricter handling of content that reaches a machine from outside the team.

Monitoring. A security watch reads our database, authentication and storage logs as they arrive, together with the GitHub organization's and the Cloudflare account's audit trails and every use of our administrative interface. It alerts the team to the signs of an attack or of someone reaching data they should not: a direct database log-in, bursts of failed log-ins, a privileged key used from outside our infrastructure, or a change to who can reach the code or the infrastructure. The logs are archived for 30 days in a store that only the watch writes to.

3. Architecture

WeMachines operates on managed infrastructure rather than self-administered servers. The application and its API run on Cloudflare's edge network; customer data is held in a managed Postgres database in Frankfurt, with file storage and authentication provided by Supabase; real-time audio and video are carried by LiveKit. A read-only copy of the database and the team's files is taken every night to a separate store under EU jurisdiction and kept for 30 days. Every provider that processes data on our behalf is enumerated in the sub-processor list in our Privacy Policy.

The app enforces a Content Security Policy that runs only its own scripts: no inline script, injected handler or javascript: link can execute. Every address our server fetches on someone's behalf, such as a link a machine opens or a picture it reads, is resolved first and refused if it points into a private network, on the first request and on every redirect. Real-time broadcasts and presence travel only on private channels that check the member's access, and a live document or call connection is closed within five minutes of its member losing access. Logging out removes the offline copies of documents, drafts and unsent messages from the device.

All traffic is served over TLS. Credentials held on your behalf - connected-account tokens such as Google, the keys and logins behind a team's plugins, and the secrets a workspace stores for its apps - are encrypted with AES-GCM before storage, under a key held outside the database. None of them can be read back through the product, by any role.

Plugins connect machines to the services a company runs on, such as Supabase or Stripe. By default each person connects their own account, and a machine acts only with the account of the person who asked it - one member's login is never usable by another, and a routine, which nobody asks in person, can only use an account connected for the whole team. An administrator decides for each plugin whether machines may only read or may also make changes, and can switch off single actions; a plugin's calls run on our servers, and every change a machine makes through one is recorded in the audit log.

4. Tenant isolation

The boundary between workspaces is enforced in the database itself, through Postgres row-level security, rather than in application code alone. Every query - including one issued in error by our own front-end - is constrained by policies that evaluate the caller's authenticated identity against their workspace membership. Columns that confer a capability, such as the GitHub installation a workspace is bound to, are writable only by the server, an invariant enforced by database triggers on both insert and update.

File attachments - the files and images added to messages, tasks and documents - are the one exception. They are stored outside those policies and served from long, unguessable links, so the link itself is what grants access: anyone who holds a file's link can open that file, and a link cannot be found by guessing or by browsing another team's data.

We treat this as the control that matters most, and it is therefore held in place by tests rather than by review discipline. A suite of regression tests fails the build if a policy loses its constraints, if an identity column ceases to be bound to the authenticated user, or if the trigger protecting capability columns is weakened. A separate audit script sweeps the live database's policy catalogue, so that a policy altered in the hosting dashboard - outside our repository - is still detected.

Switching between workspaces always performs a full page load. This is deliberate: it guarantees that in-browser state belonging to one workspace cannot survive into another session or reach the AI's context. That behaviour is itself enforced by an automated test and cannot be removed as an optimisation.

5. Customer content and AI

AI features transmit the relevant portion of your workspace - the messages, tasks, documents or code the request concerns - to an AI provider in order to generate a response, routed through our AI gateway. WeMachines picks the model for every job: each machine runs on a level, Efficient, Balanced or Ultra, whose model we choose, and calls, code, apps and built-in features each run on a model we picked for that work. The sub-processor list in our Privacy Policy names every provider that can receive your content.

The models we pick are routed only to zero-data-retention endpoints, where the provider does not store what is sent. That holds for every workspace, with nothing to turn on, and a request fails rather than reach an endpoint that keeps data. Pictures are drawn, and scanned documents read, by models on those same endpoints. Web research keeps no data either, since LinkUp, our search provider, is zero data retention, and a link is fetched by WeMachines itself. Speech on calls and in huddle transcription runs through LiveKit Inference, which is zero data retention too, and calls are not recorded.

The one exception is a machine's own web browser. It runs on Browserbase, which sees the pages a machine opens and what it types into them; its sessions are not recorded or logged. An organization can turn the browser off for its teams, and its machines then read pages without one.

Secrets never reach a model. Before any request leaves our servers for a model, the secrets in it are hidden: passwords, API keys and tokens, card numbers, national identity numbers, one-time codes, and sign-in and reset links, in the messages, documents, emails and tool results the request carries. The model sees a placeholder, and a machine cannot write a placeholder back over the real value. Two paths keep the exact text, because their work needs it: a coding run, which edits the code it reads, and a machine reading its own mailbox, where the codes are what it was sent. In a person's connected mail, the same secrets are hidden whenever a machine reads a message, and machine memory never learns from an intimate thread.

Content from outside the team is untrusted. An email from a stranger or a web page a machine reads can carry instructions written to mislead it. A run that has read such content cannot publish team data through an app without a person approving exactly what would become public, a picture a machine places in a task or document loads only when someone clicks it, and the links such content can send a machine to are limited, so an injected instruction cannot quietly carry data out.

Customer content is not used to train models. WeMachines neither builds nor fine-tunes models, and we access providers through their API tiers, under which submitted content is not used for model training. Your workspace content is not used to improve the Service for other customers.

Model access is metered per workspace and routed through our own server, so an AI provider key is never present in the browser.

6. The coding machine

WeMachines can run a coding machine against a GitHub repository you connect. That machine executes code in a cloud container, and the container is treated as the least-trusted component in the system by design, because the instructions it follows originate in task titles and comments that any workspace member can author.

  • No shared credential enters the container. It receives no AI provider key, no database service key, and no broadly scoped access token.
  • Model calls are proxied. The container holds only a short-lived, cryptographically signed token scoped to a single run; the provider key is injected server-side. A leaked token is usable only through our metered proxy, only for that run, and only until it expires.
  • Repository access is scoped to the bound repository. The GitHub token is minted for that repository alone, with a minimal permission set, never for the full breadth of the installation.
  • Administrator secrets remain with administrators. Build environment variables are injected only where the member launching the run holds administrator privilege.
  • Changes are delivered as pull requests. The machine proposes; a human reviews and merges. It does not write to your default branch.

These properties are enforced by an automated test that fails the build if a launcher places a resolved provider key on the container payload or omits the run-scoped token.

7. Authentication & access

WeMachines accounts are passwordless. A new account is created with a Google or Apple account, and an existing account can also log in with a one-time code sent to its verified email address. No password is requested, stored, or capable of being disclosed. Sign-in is protected by a bot-prevention challenge, the device a new account signs up from is recognised so that one person or script cannot make accounts in bulk, and disposable email domains are rejected at account creation by a database-level hook covering every sign-up path, including OAuth and direct API calls. A changed email address takes effect only once it is confirmed.

Two-factor authentication is available on every plan, using a time-based one-time password from any authenticator app. An administrator can require it for their whole team, and that requirement is enforced in Postgres rather than in the browser: the membership and role lookups every row-level security policy calls return nothing for a session that has not presented its second factor, and the real-time relay asks the same question, so an unverified session does not load the team's data at all. Recovery codes are issued at setup and stored only as hashes. Two things this does not cover, stated plainly: an MCP client already connected keeps its access until it is disconnected, and requiring two-factor is per team, not per account.

SAML single sign-on is part of the Enterprise plan. An organization connects its identity provider for email domains it has proved with a DNS TXT record, and a provider can only ever log in addresses at those domains; the SAML exchange itself is handled by Supabase Auth, so we never parse an assertion. Once someone has logged in through it, an organization administrator can require single sign-on for those domains: other ways to create an account or start a session are then refused by database hooks, and existing sessions end within the hour, while the organization's own administrators keep another way in. Someone logging in for the first time is invited to the team the organization chose. SCIM provisioning is not available yet, and sign-in starts at WeMachines rather than from the provider.

MCP connections - an AI client such as Claude or Cursor reaching a workspace - are grants the person made and can take back. Settings → Security lists each one with a Disconnect button, and logging out everywhere else revokes them all. An authorization code works once, a replayed one revokes its grant, refresh tokens rotate on every use and an old one presented again revokes the grant too, and every call checks that the grant still stands.

Workspaces distinguish administrator, billing, member and viewer roles, enforced by the same row-level security layer as the rest of the data model. They form a ladder rather than two axes: spending the workspace's money - buying credits, changing the plan, managing cards and billing details - is the billing role's power, and an administrator holds it without needing the role, so handing someone the card does not hand them the member list. A viewer is the rung below member: they read what a member reads and write nothing, which is refused by restrictive policies on every table rather than by hiding the controls - the AI will not act for them and the document relay drops their edits. Invitations are single-use and are consumed within the transaction that creates the membership, so a revoked or previously used invitation cannot be replayed. Removing a member revokes access to workspace data, real-time sessions and outstanding invitations. It does not revoke a file link they kept: an attachment is served from its unguessable link, which keeps working for whoever holds it.

Every workspace keeps an append-only audit log - access changes including shared channels and public links, configuration changes including secrets and the plan, every coding-machine run from start to finish, every routine run, and each export of the data. Events are recorded on every plan and readable by administrators on Grow. Anything the browser can change is recorded by a database trigger inside the same transaction as the change itself, so the action cannot occur without its record; the rest is written where the action is only possible, on the server. Each entry names the person who acted and freezes their email beside it. No client, of any role, can edit or delete an entry. It exports to CSV.

8. Secrets, supply chain & change management

Our build pipeline treats a disclosed credential, a compromised dependency and an unreviewed change as the same class of risk.

  • Secret scanning gates every commit and pull request. A scanner runs as a pre-commit hook and as a required continuous-integration check, and can sweep the full repository history on demand.
  • Static analysis. CodeQL analyses the codebase on every change.
  • Dependency review. Pull requests introducing a dependency with a known vulnerability are flagged before merge, and every pull request's dependency changes are reviewed for typosquats, install scripts, obfuscated code and changes of ownership.
  • Malicious-package checks. Every lockfile is checked against the public database of known-malicious packages on every pull request and every day.
  • A cooldown on new releases. A package version must be at least 7 days old before it can be installed, the window in which most hijacked releases are caught and pulled. A release with weaker provenance than the ones before it, an indirect dependency fetched from a git repository or tarball, and any install script nobody has reviewed are refused, and a test fails the build if one of these settings is loosened.
  • Pinned build actions. Every third-party continuous-integration step is pinned to a full commit hash rather than a mutable tag, so a compromised upstream release cannot silently enter the pipeline. Application dependencies are pinned to exact versions.
  • No credential resides in the repository. Environment files are excluded from version control, and their committed counterparts contain placeholders only.
  • Every production change is reviewed by a second person. Production changes only through a pull request that someone other than its author approves, with signed commits and the required checks passing. The rule binds administrators too, and nobody can bypass it.
  • Nothing reaches production from a laptop. The app, its Workers, the voice agent and database migrations are deployed by CI from the reviewed branch, and production credentials are held in our providers' secret stores, not on anyone's computer. Database changes run on the development database first, and production refuses one that has not.

9. Source confidentiality

WeMachines' source code is not published. This is a data-protection decision rather than a commercial one. The codebase is a precise description of how customer data is stored, isolated and accessed; publishing it would provide anyone probing for a way in with the same map our own engineers work from. We are not prepared to accept that exposure on behalf of the teams whose private work we hold.

Transparency about what happens to customer data does not require public source. This page describes the architecture and its controls, the Privacy Policy enumerates every sub-processor able to touch that data, and any question a review still needs answered is answered directly.

10. Data ownership, export & continuity

  • Export is self-serve, on every plan. A workspace administrator may download the workspace's full contents at any time from Settings → Danger Zone. There is no paywall, no request form, and no dependency on our availability to action it. Our Terms of Service commit us to maintaining this.
  • Source code remains in your repositories. WeMachines reads from, and opens pull requests against, your own GitHub repositories. It is not the system of record for your source, so disconnecting the integration carries no data cost.
  • Deletion is effective. Deleting a workspace or account removes the associated data, subject to residual copies in routine backups for a limited period and to any legally mandated retention. The detail is set out in our Privacy Policy.
  • Wind-down is contractual. Should we discontinue the Service, we commit to a minimum of 60 days' notice with export available throughout - a term of the contract, not a marketing statement.

11. Reporting a vulnerability

Email [email protected]. This is the sole reporting channel; please do not disclose details publicly before a fix has shipped.

Response targets: acknowledgement within 48 hours, and an assessment with a remediation plan or a fix within 7 days. The hosted product deploys continuously, so confirmed fixes reach production without waiting on a release cycle.

Research conducted against the live product must use only accounts and workspaces you have created yourself, must not access or exfiltrate another customer's data, and must not include denial-of-service or volumetric testing. Good-faith research observing these conditions will not result in legal action, and we offer credit for confirmed reports, or anonymity where preferred.

12. Data location & sub-processors

The workspace database is held in Frankfurt and its nightly backups under EU jurisdiction, and product analytics are processed within the European Union. Our infrastructure and AI providers operate globally, and certain providers process data in the United States, AI models among them, so we do not describe WeMachines as keeping data in the EU. Where personal data leaves the EEA, the UK or Switzerland we rely on the European Commission's Standard Contractual Clauses, with the UK Addendum where the UK GDPR applies, or on an adequacy decision where one covers the destination. The complete and current list of providers, and what each processes, is maintained in the Privacy Policy.

Our Data Processing Agreement already forms part of the Terms, so it applies to your workspace whether or not you have asked for it; a copy comes by email. Security questionnaires, Data Processing Agreement requests and architecture questions are answered directly at the address below.

13. Common questions

Is WeMachines SOC 2 certified?

Not yet. Our SOC 2 Type II observation period began on 15 November 2026, with an independent auditor testing how our controls operate across it, but no report has been issued and WeMachines holds no certification today. We will publish the report here when it is issued. ISO 27001 is under evaluation only.

Do you train AI models on our content?

No. WeMachines neither builds nor fine-tunes models, and we reach providers through API tiers under which submitted content is not used for training. Every model we pick runs on zero-data-retention endpoints, so the provider keeps nothing it is sent, and the secrets in a request are hidden before it leaves our servers. Your workspace content is never used to improve the service for other customers.

Is our data stored in the EU?

The workspace database and its nightly backups are in the European Union, in Frankfurt and an EU-jurisdiction store, and product analytics are processed there. AI requests, real-time media and some other providers process data elsewhere, including the United States, so we do not say that your data never leaves the EU. Those transfers rely on the Standard Contractual Clauses, and the Privacy Policy names every provider and what it handles.

Have you had a penetration test?

Yes. In November 2026 we ran an internal penetration test against the database, apps, the coding runner, the AI tools and the desktop app. It found no way from one team’s data into another’s. Its findings were fixed within days or scheduled, and each fix carries a regression test.

Can WeMachines be self-hosted?

Not fully, but partly today. WeMachines is hosted at app.wemachines.com, and the desktop app can run a task’s coding machine on your own computer, through a coding agent you have installed - Claude Code, Codex, OpenCode, Copilot CLI and ten others - so its work stays on your hardware. With Ollama installed, the run can use a model on that computer too, so no prompt from it reaches a model provider at all - the run’s timeline still syncs here for your team to watch, but the model answering it is yours. A fully self-hosted edition - the platform itself on infrastructure you control - is a direction we are committed to, with no date yet.

Is WeMachines HIPAA compliant?

No. WeMachines is not a business associate, offers no BAA, and protected health information must not be stored in a workspace.

Is a Data Processing Agreement available?

Yes, and it is already in force. Our Article 28 DPA forms part of the Terms of Service, so it applies to every customer without anything to sign or request; email [email protected] for a copy, countersigned if you need one. We also complete customer security questionnaires. Product analytics are processed in the European Union and we do not use session replay, so no recording of a workspace is ever made. The complete list of sub-processors and what each one handles is maintained in the Privacy Policy.

Do you support two-factor authentication?

Yes, on every plan, using a time-based one-time password from any authenticator app. An administrator can require it for their whole team, and the requirement is enforced in the database rather than the browser - a session that has not presented its second factor cannot read the workspace at all. Recovery codes are issued at setup. SAML single sign-on is part of the Enterprise plan.

Do you support SAML single sign-on?

Yes, on the Enterprise plan. An organization connects any identity provider that speaks SAML 2.0, such as Okta, Microsoft Entra ID or Google Workspace, for email domains it has proved with a DNS record. It can then require single sign-on for those domains, and someone logging in through it for the first time is invited to the team the organization chose. SCIM provisioning is not available yet, so an administrator removes a departing person from their teams.

Is there an audit log?

Yes. Events are recorded on every plan and the log is readable by workspace administrators on Grow. It records access changes (members, invitations, shared channels, public links, two-factor), configuration changes (the repo, integrations and plugins, secrets, the plan), every change a machine makes through a plugin, every coding-machine run from start to finish, every routine run, and data exports. It is append-only - no client, of any role, can edit or delete an entry - and it exports to CSV.

How is one workspace kept out of another?

Tenant isolation is enforced in Postgres by row-level security rather than in application code, so a bug in our front end cannot reach another team’s data. File attachments are served differently: from long, unguessable links rather than through those policies, so a file’s link works for whoever holds it. There is exactly one path between two teams: a shared channel. Between two customer teams, an administrator on each side has to create and accept it; the one provisioned exception is the channel every workspace shares with the WeMachines team, our built-in support line. Either way it carries only the messages people post there, attachments included; no tasks, documents, member lists or AI context cross it. Every confirmed audit finding is converted into an automated regression test, so the same defect cannot return.