Administration
Security
Review execution, credential, audience, integration and memory boundaries.
Merlin connects organization requests to agents running in user-owned environments. This page covers two things separately: how Merlin handles your data, and how permissions work when you use Merlin's features.
How Merlin handles your data
Work runs on machines you control
Requests run on Claude Code or Codex on a machine a workspace member connected. Merlin does not host a model of its own and does not stand between your prompts and the provider: model usage goes to the Claude Code or Codex account already signed in on that machine, and the resulting usage and billing stay with that provider account.
The files, repositories and tools the agent uses are the ones already on the device. Merlin sends the request and the context it was given. It does not upload the working directory.
What stays on the device
- Provider credentials for Claude Code and Codex.
- Personal MCP server configuration and the credentials inside it.
- Repository contents, local files and shell environment.
- Each conversation's working directory, which lives under Merlin's local state on the machine that ran it.
None of these are uploaded to Merlin as part of capability inventory. Merlin learns which skills and MCP servers exist so it can route work, not what the credentials are.
What Merlin stores
Merlin stores what it needs to identify people, route requests and deliver results:
- Accounts and memberships: your sign-in identity, which workspaces you belong to and which Slack, Linear or GitHub identities you linked.
- Workspace integrations: the authorization credentials for the workspace's Slack, Linear and GitHub installations.
- Request records: which thread, issue or pull request a request came from, which runtime handled it, its status and delivery state.
- Shared workspace context: skills published to the workspace catalog, memory files, workspace guidance and automations. Owners and admins can edit workspace guidance, edit or delete memory they can see, manage visible workspace automations, and archive or delete published skills.
Slack remains the system of record for what people wrote. Merlin keeps pointers to messages and, where it must notice a change, a digest of the text. It does not keep an independent copy of your threads. Message and file content is held only while a request is in flight, and file attachments are recorded as metadata without Slack's private download URLs. A message deleted in Slack before Merlin runs it is not run.
Who can see stored data
Stored data is scoped to the workspace. Memory follows the audience of the channel it came from: a private channel's store is visible only to that channel's current members, with no owner or admin bypass. Personal MCP inventory is visible only to its owner. See Memory boundaries and Members and roles.
Deleting data
- Disconnecting a device revokes its credentials and stops future use. Its historical request records remain in the workspace.
- Removing an integration or unlinking a service identity stops Merlin from acting through it. It does not erase information the connected provider retains.
- Deleting a workspace is available only to the owner, requires typing the workspace name, cancels any active subscription and irreversibly removes workspace-scoped data. Your global account and other workspace memberships remain.
- Deleting your account is available to everyone under Settings → Account and requires typing your account email. Workspaces you own alone are deleted with it, and a workspace you own with other members must be transferred first. Skills, automations, memory and conversations you created stay in their workspaces.
- For removal requests that the web app does not cover, contact support.
Current processing and retention terms are in the privacy policy.
Permissions when using Merlin
The rest of this page describes the boundaries that apply while teams use Merlin's features: who can start work, where it may run and where results go.
Follow a request across its boundaries
| Boundary | What controls it |
|---|---|
| Source audience | Slack, Linear or GitHub decides who can read and participate in the originating conversation. |
| Workspace admission | Merlin binds external identities to workspace members and applies the workspace's join policy. |
| Runtime eligibility | Ownership, private or public access, enabled state, availability and capacity decide who can use it. |
| Local execution | The operating-system user and local agent determine which files, credentials, skills and tools exist. |
| Result destination | Progress and results return to the originating conversation under that source's audience controls. |
Task instructions, custom instructions and memory guide the agent. They do not enforce permissions. Enforced limits come from the source service, Merlin's admission and runtime rules, and the permissions of the selected local environment.
Local execution
Claude Code and Codex run on a member's connected machine with that provider's local account. Requests and relevant context pass through Merlin to the selected runtime, and results return through the originating service.
Local execution does not mean all information remains on the device. Slack, Linear, GitHub, model providers, MCP tools and Merlin process the information needed for the authorized task. Review the privacy policy for current processing and retention terms.
Each conversation receives its own working directory under Merlin's local state. This is not an operating-system sandbox or a separate user account. The agent can run tools and commands with the access available to the local provider environment.
Runtime sharing
New runtimes begin private. Only their owner can change them to public.
A public runtime delegates real execution capability to eligible workspace members. Authorized work can use the runtime's enabled local skills, MCP tools, credentials and files available to the agent. Merlin does not ask the device owner for a new mid-run approval for each command.
Catalog visibility does not narrow that execution boundary. Making a local skill private or hiding raw MCP configuration does not stop an authorized task on the runtime from using the enabled capability.
Return the runtime to private, disable or remove a capability locally, or use a separate runtime when it should not be available to shared work.
Review a runtime before sharing it
Before making a runtime public, review:
- Which repositories and files the local agent can read or change.
- Which Git and provider credentials are available, and what actions they allow.
- Which local skills and MCP servers are enabled.
- Which shells, package managers and other tools the agent can run.
- Which provider account receives model usage and billing.
- Which tasks teammates may delegate without a separate approval from the device owner for every command.
If that combined capability is too broad for shared work, keep the runtime private or connect a separate environment with narrower access.
Device and connector credentials
The installed client stores local connection information used to authenticate the device and its workspace approvals. A machine approved for several workspaces activates one workspace at a time.
Personal MCP configuration and credentials, plus model-provider credentials, remain on the device and are not uploaded as capability inventory. Server-operated Slack, Linear and GitHub integrations are different: Merlin stores and uses the authorization credentials needed to run those connectors.
Disconnecting a device or integration stops or limits future use, but it does not automatically erase all historical records or information retained by the connected provider.
Integrations and identities
Any member can make a service's first connection. After that, an owner or admin manages each workspace installation. Individual members manage their personal service identities. The installation authorizes the workspace connector, and the personal binding tells Merlin which member a Slack, Linear or GitHub actor represents.
Every connector limits actions to the installation and resources the provider authorized. GitHub repository selection stays in GitHub. A local GitHub MCP is separate and acts with the device owner's credentials.
Channel audience
The destination's own membership remains part of the audience boundary. An admin role does not grant membership in every private Slack channel or access to every private-channel automation.
Runtime access controls who may execute on a machine. It does not decide who may read the source Slack thread, Linear issue or GitHub repository. Use the source service's access controls for that audience.
Memory boundaries
Public Slack channel memory can inform work across the workspace. A private channel reads public memory plus its own private store, and only current members can view that store in the web app.
DMs, group DMs, external shared channels and non-Slack-born conversations read public memory but do not write a store. Channel visibility changes never promote existing private notes or retract facts already saved publicly. See Memory.
Account and workspace controls
Merlin sign-in uses Google or an email code. With an email code, there is no Merlin password to manage. Owners and admins control admission, integrations and shared workspace settings. Only the owner can transfer ownership or delete the workspace.
For suspected unauthorized access or material that should be removed, contact support with the workspace, affected resource and approximate time. Do not send passwords, complete tokens or full payment-card details.