Skip to content

Who can see and run what ​

This page puts L2M's access model on one page. The details are in Authentication and RBAC and Service accounts and API keys.

How a request is checked ​

  1. The global role. Every route needs a role. Roles rank viewer < operator < builder < admin, and a higher role passes wherever a lower one does.
  2. The workflow's project. Then the route checks a permission (such as workflow:execute) in the workflow's project. It comes from the person's project membership. Without one, it depends on PROJECT_ISOLATION (below).
  3. Shares. A share can add read or run on one workflow. A share never gives edit, delete, publish or re-sharing. A person share never takes away what someone already has. Only when it is their only way to the workflow (no membership, no role that reaches the project under the isolation mode, not an admin) does it hold them to its level.
  4. API keys. A key acts as its owner. Its scope can narrow that, never widen it.

Both checks must pass. A membership cannot let a viewer call a builder route, and a role cannot reach a project the person has no access to.

The main table ​

What each kind of access gives on one workflow.

WhoReads itSees runsRuns itChanges itSession memory of their runs
AdminYes, every workflowAll, also of deleted workflowsYesYesThe workflow's
Builder with workflow:write in the projectYesAllYesYes (delete and publish if the project role grants them)The workflow's
Operator with workflow:execute in the project (an editor membership too)YesAllThe released version, with their own inputNoTheir own
Viewer with workflow:read in the projectYesAllNoNoTheir own (signed-in chat)
Member of a project the workflow is shared toYesAllWith an execute share, if they may run workflows in that project: the released version, with their own inputNoTheir own
Person share, Can viewYesOnly their ownNoNoTheir own (signed-in chat)
Person share, Can view and runYesOnly their ownOperators and up: the released version. Viewers: noNoTheir own, also with a key of their own
API keyAs its owner, within the key's scopeAs its ownerThe released version (the draft with channel=draft when it may edit the workflow)As its owner, within the key's scopeThe workflow's (exceptions)
Service account (through its keys)As its role and membershipsAs its roleAs an API keyAs its roleThe workflow's
Webhook, schedule, public chat or form, MCP gatewayNo user checkNo userYesNoThe workflow's

"Only their own" applies when the person share is their only way to the workflow. See Own runs only.

Who may edit a workflow is one rule everywhere: a global role of builder or higher and workflow:write on the workflow. It decides who runs the draft (on /execute, the manual trigger route and a retry), who may use the editor's run options, who may replay a run with its recorded MCP calls, who may replay golden runs, start replay jobs and eval runs (they run the draft or a candidate), whose runs use the workflow's session memory, and who sees the editor's edit controls (and, on the Runs page, Replay from here, Replay with the recorded MCP calls and the golden run controls). An operator with an editor membership may not edit: the role caps it. A builder who may only run a workflow (through an execute share to their project, or a person share that is their only way to it) is treated like an operator for it.

Roles ​

RoleIn short
viewerReads workflows, runs and approvals.
operatorA viewer who may also run, queue and cancel runs, decide approvals and answer tools' questions. Cannot edit.
builderAn operator who may also create, edit, delete and publish workflows, retry and replay runs, and manage secrets and projects.
adminEverything, including users, roles, single sign-on, policy and the audit log.

Project roles set the permissions inside one project:

Project rolePermissions
Project adminRead, write, execute, delete and publish workflows; read, write and use secrets; manage the project and its members
EditorRead, write, execute and publish workflows; read and use secrets
ViewerRead workflows and secrets
Custom roleThe permissions an admin lists in it
  • Only admins create, change and delete custom roles.
  • A custom role with no project is deployment-wide. It is the only way to give a non-admin legal holds (legal_hold:manage) or data-subject requests (data_subject:manage). Only an admin may hand out such a role.
  • A membership whose role grants nothing locks the person out of that project.

Project isolation ​

PROJECT_ISOLATION decides what a non-admin gets in a project where they have no membership.

SettingWithout a membership
role (default)Their global role's permissions. Every project is open to every user until an admin adds memberships.
strictNothing. They see only projects they are a member of, and what is shared with them.

Under strict:

  • Default-project secrets and MCP servers need an explicit share, like any other project's.
  • A non-admin who creates a project becomes its project admin.
  • Someone in no project lands on Home with the workflows shared with them.

See Project access before switching an existing install.

Shares ​

Project sharePerson share
Givesread or execute to the members of another projectCan view (read) or Can view and run (execute) to one person
Who manages itproject:invite in the workflow's project (who may add members), or an admin, with the member-change step-upA member of the workflow's project with project:invite (a project admin), or an admin, with the same step-up. The role role isolation lends a non-member does not count
Running through itNeeds workflow:execute in the project it is shared toNeeds a role that may run (operator and up). A viewer's run share only reads
Runs they seeAll runsOnly their own, when the share is their only way to the workflow
Not allowedSharing to the owning projectYourself, service accounts, people without an account (invite them first)
  • A share never gives edit, delete, publish or the right to share it on.
  • Runs through an execute share (either kind) may use the workflow's secrets, as runs of its own project do.
  • Person shares go with the workflow or the person when either is deleted.
  • A deactivated person's person shares give nothing until they are enabled again.

Details: Sharing a workflow with people.

Own runs only ​

Someone who has a workflow only through a person share sees only their own runs of it: the runs they started, and the runs that used their session memory. It applies only when the share is their only way to the workflow: no membership or role that reaches its project under the isolation mode, no membership of a project it is shared to, not an admin.

  • Anyone else's run answers 404, as a missing run. Lists are filtered before paging.
  • They see and decide only the approvals and tool questions of their own runs.
  • Data built from many people's runs (golden runs and sets, captures, eval and replay runs, rule events, the dead-letter queue) leaves the workflow out.
  • GET /api/workflows/:id/access answers ownRunsOnly: true.

A person share never takes away what someone already has. Under strict, a non-member's share is their only way in: they see only their own runs, and the share caps them. They read it with Can view, also run the released version with Can view and run, and cannot save, publish, delete, duplicate or re-share it (the API answers 403, and the editor and Home hide those controls). Nothing else of that project is theirs, including what is built from other people's runs: golden sets, evals, release-gate reasons and replay captures. Under role, everyone's role reaches every project, so a share there adds what it gives and takes nothing away: they keep every run and everything their role gives.

Only the project's own members with project:invite (and admins) share its workflows with people and add, change or remove members, never beyond the permissions of their own membership, and nobody but an admin changes or removes their own membership. A workflow shared with people moves to another project only by an admin, or by a member with project:invite in both projects. MCP servers assigned to a project are hidden on every server route (tools, resources, prompts, OAuth status, changes, overview and the playground) from anyone who may not read that project.

Details: Own runs only.

Session memory ​

Session memory, the session tool cache and session artifacts are stored per project. Two projects never share them.

Some runs keep them to the person who runs:

  • runs by anyone who has the workflow only through a person share, whatever their role, signed in or with a key of their own;
  • runs by a signed-in person who may not edit the workflow: operators (also with an editor membership), builders who may only run it, and viewers in a signed-in chat.

These runs read and write under the person's own key. Another person who sends the same session id starts an empty session. Sub-workflows, the error workflow, queued runs and the part after an approval keep the same person's key.

People who may edit the workflow (and admins), other API keys, service accounts, schedules and webhooks use the workflow's sessions.

  • A retry or replay keeps the run's owner. The owner's own retry continues their session. Anyone else's retry runs in a namespace of its own and reads none of the owner's memory.
  • A run of a deleted person is not run again (409).
  • A Simple Memory or Session Artifact namespace may not start with ~person:. That prefix marks one person's sessions.

Details: Running workflows by role.

Running a workflow ​

  • A signed-in person who may edit the workflow (builder role or higher and workflow:write) runs the draft. Everyone else runs the released version (the published one, or the saved workflow while nothing is published and no release gate is on), and gets 403 for channel=draft.
  • Anyone who may not edit the workflow runs with their own input only. Editor options (startNodeId, single-node runs, pinned data, nodeOutputs, sourceExecutionId, record, or a graph sent with the request) answer 403 with refusedOptions.
  • Their runs use no pinned data, and their timeout is at most WORKFLOW_EXECUTION_TIMEOUT_MS.
  • Queueing and cancelling need operator and workflow:execute. Retry needs builder; a builder who may not edit the workflow retries on the released version, without the editor's options. Replaying a run with its recorded MCP calls needs someone who may edit the workflow.
  • A queued job runs only if the person who queued it may still run the workflow when it starts.

Once a run is going, it reaches only its own project's secrets, MCP servers, knowledge bases and sub-workflows, whoever started it. See What a running workflow can reach.

API keys ​

  • A key belongs to a person or a service account and acts as that account, with its memberships.
  • Role ceiling (role:operator, for example): the key acts with the lower of the ceiling and the owner's role.
  • Project list (project:<id>): the key reaches only those projects, acts as builder at most, and may call only the routes that check projects. Everything else answers 403.
  • A key made with another key cannot reach further than that key and expires no later.
  • Work a key starts that goes on later (a queued run, an approval) keeps the key's limits.
  • A personal key stops working when its owner is deleted.
  • With step-up on, personal keys are refused on security actions (creating keys, changing roles and the like).

Details: Key scopes.

Service accounts ​

  • An identity for automation. Admins manage it.
  • It has a global role and project memberships, like a person, and the same checks apply.
  • It cannot sign in. Only its keys, made by an admin, authenticate it.
  • It never decides approvals and cannot be the target of a person share.
  • Its runs use the workflow's sessions.

Details: Service accounts.

Approvals ​

To decide a paused run, a person needs all of these:

  1. workflow:execute on the workflow, and on every workflow along the sub-workflow path to the gate.
  2. To match the gate: a listed role (exact match), or being named in its users. With nobody listed, operator and up.
  3. Not to have started the run, unless the gate allows self-approval (off by default).
  • Service accounts never decide.
  • Someone with own runs only decides only gates in their own runs.
  • Roles and access are checked again when the decision is taken.
  • The resumed run runs as the person who decided, inside the workflow's project.

Details: Approvals.

Admins ​

  • Admins pass every project check and see the runs of deleted workflows.
  • The gate's approver list and self-approval rule still apply to them.
  • A run they start or approve still reaches only its workflow's project. Admins skip secret:use, not the project rule.
  • An admin's key with a project list acts as builder at most.
  • The last admin who can sign in cannot be demoted or deleted.

Details: Keeping admin access.

This website (not the L2M product) counts page views with GoatCounter, without cookies.