Skip to content

sumsub/agent-skills / skills/sumsub-create-workflow

sumsub-create-workflow

Verified

Create a Sumsub applicant workflow — verification routing (levels, branches, country/age rules, final-rejection or manual-review steps) or an action workflow (post-verification tagging, notes, source-key changes). TRIGGER on requests to create/build/add a workflow or a flowchart-style routing description. Builds, validates, and saves a draft, then publishes it — gated by live traffic — automatically when the workflow's traffic is low, only after explicit confirmation when it's high. Publishing changes LIVE traffic — see the Danger section. SKIP for editing arbitrary fields of an existing revision, or for questionnaires/levels (separate skills).

references/workflow-notices.md

View on GitHub
# Workflow validation notices

*(reference — the meaning of each validation notice the API can return. Keys are authoritative
as the API returns them in `notices[].message`; the meanings here are curated to match. The API
is the source of truth — if a notice comes back that isn't listed here, treat its own message as
canonical.)*

`workflow_api.py validate` (and `post`) returns a `notices[]` array. Each notice carries a
`message` (a key in the table below), a `severity`, the offending `nodeId`/`edgeId`, and a
`params` map filling in the specifics — so the notice itself tells you *what*, *where*, and *how
serious*; this table tells you only what the key **means**. **Severity is a property of the
returned notice, not of the message key** (the same key can come back at a different severity),
so read it off the notice — the catalog isn't organized by it.

What a notice's severity means for you:

- **`error`** blocks publish (the API refuses a revision carrying any error notice), so a draft
  with open errors is **unfinished**. An error is one of two kinds: a **missing reference** — a
  level / tag / source-key / expression path / transition target that doesn't exist — which you
  *ground* (reuse, create, or mark pending; never repoint just to go green); or a **structural**
  problem in the graph, which you fix in the spec (most of these the builder rejects before
  validate even runs). The description tells you which.
- **`warning`** never blocks, but usually marks a real bug — most often a condition reading data
  no preceding level produces (a placement issue; see *Place each gate at the earliest point* in
  [workflow-patterns.md](workflow-patterns.md)). Read it; don't paper over it.
- **`info`** is advisory.

## Catalog

| key                                               | meaning                                                                                                                                                                                                                             |
|---------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `actionLevelsInActionWorkflowsOnly`               | An action level is used inside a default (non-action) workflow, where action levels are not allowed.                                                                                                                                |
| `actionLevelStartRequired`                        | An action level has incoming edges but no action-level predecessor, so the workflow does not begin with an action level node as required.                                                                                           |
| `approachingActionLimit`                          | The number of actions on a single node is nearing the per-node maximum.                                                                                                                                                             |
| `approachingCriteriaPerEdgeLimit`                 | The number of condition criteria on a single edge is nearing the per-edge maximum.                                                                                                                                                  |
| `approachingEdgeLimit`                            | The total number of edges in the workflow is nearing the maximum allowed.                                                                                                                                                           |
| `approachingNodeLimit`                            | The total number of nodes in the workflow is nearing the maximum allowed.                                                                                                                                                           |
| `approachingReviewButtonIdsLimit`                 | The number of rejection tags on a final-rejection node is nearing the maximum allowed.                                                                                                                                              |
| `approachingReviewRejectLabelsLimit`              | The number of rejection labels on a final-rejection node is nearing the maximum allowed.                                                                                                                                            |
| `approachingTagsLimit`                            | The number of tags added by a single tags action is nearing the maximum allowed.                                                                                                                                                    |
| `approachingTagsToRemoveLimit`                    | The number of tags removed by a single tags action is nearing the maximum allowed.                                                                                                                                                  |
| `approachingTotalActionsLimit`                    | The total number of actions across all nodes is nearing the maximum allowed for the workflow.                                                                                                                                       |
| `approachingTotalCriteriaLimit`                   | The total number of condition criteria across all edges is nearing the maximum allowed for the workflow.                                                                                                                            |
| `approachingTotalTagsLimit`                       | The total number of tag entries (added and removed) across the workflow is nearing the maximum allowed.                                                                                                                             |
| `argumentNotFoundInContext`                       | A function argument references an expression that is not available in the evaluation context.                                                                                                                                       |
| `argumentTypeMismatch`                            | A function argument resolves to a type that does not match the function's expected parameter type.                                                                                                                                  |
| `blueprintRequired`                               | A KYT case-creation action's node has no valid associated blueprint.                                                                                                                                                                |
| `clientListsBothSidesNotSupported`                | A list condition compares two client-list expressions against each other, which is not supported.                                                                                                                                   |
| `conditionalNodeNoConditions`                     | A branching (exclusive-choice) node has no outgoing edge carrying a condition or review decision, so it cannot branch.                                                                                                              |
| `conditionValueAsExpression`                      | A criterion's literal value looks like a field path, which usually means a Field selector was intended where a plain Value was entered.                                                                                             |
| `consecutiveActionNodes`                          | An action node's only incoming edge originates from another action node, producing two action nodes back to back.                                                                                                                   |
| `defaultEdgeMustBeLast`                           | On a branching (exclusive-choice) node, the default "else" edge — the one with no conditions and no review decisions — is not the last outgoing edge.                                                                               |
| `deviceCheckWarning`                              | An expression reads device-intelligence data, but none of the previous levels runs a device check, so that data is never populated for this expression.                                                                             |
| `disallowedNodeSequence`                          | A node's type is not permitted to follow the type of the node that precedes it.                                                                                                                                                     |
| `duplicateLevel`                                  | The same level is referenced by more than one node within a single workflow.                                                                                                                                                        |
| `edgeTargetRequired`                              | A graph edge points to no target node, leaving that branch of the flow disconnected.                                                                                                                                                |
| `emptyFieldNoActionLevel`                         | An action field is referenced although no action level precedes this step, so the field will always be empty at evaluation time.                                                                                                    |
| `expressionCountryListRecommendation`             | A country-field condition enumerates a large number of countries inline; using a client list with alpha-3 country codes is recommended for maintainability (build it with `sumsub-manage-client-lists`).                                                                         |
| `expressionEmptyList`                             | An in / not-in condition is checked against an empty list literal, so it can never match anything.                                                                                                                                  |
| `fieldPredefinedValuesWarning`                    | A criterion compares a vocabulary-backed field against literal values that are not part of that field's predefined vocabulary, so the comparison is unlikely to ever match.                                                         |
| `functionArgumentCountMismatch`                   | A function call supplies a different number of arguments than the function definition requires.                                                                                                                                     |
| `functionArgumentsEmpty`                          | A function-call criterion was supplied with no arguments at all.                                                                                                                                                                    |
| `functionNotFound`                                | A function-call criterion references a function name that is not defined in the workflow's function set.                                                                                                                            |
| `idDocWarning`                                    | An expression reads data from a specific ID-document set type (such as a questionnaire or a face check), but no preceding node in the flow collects that document type, so the field will be empty when the condition is evaluated. |
| `inEdgeRequired`                                  | A node has no incoming edge and is therefore unreachable in the flow.                                                                                                                                                               |
| `invalidExpression`                               | A criterion uses an expression that is not present in the available data model — typically an unknown or misspelled field path.                                                                                                     |
| `invalidLevelTypeChange`                          | A transition connects levels with incompatible applicant types, for example moving from a KYC level to a KYB level.                                                                                                                 |
| `invalidSourceKey`                                | A source-key action references a source key value that does not exist.                                                                                                                                                              |
| `kybConversionError`                              | A KYB 2.0 (WebSDK-next) company level transitions to an old-structure KYB level; the two generations cannot be mixed in one flow.                                                                                                   |
| `labelsOrRejectionTagsRequired`                   | A final-rejection node defines neither rejection labels nor rejection tags, so it has no rejection outcome to apply.                                                                                                                |
| `levelApplicantTypeMismatch`                      | In an action workflow, the target level in the standard workflow has a different applicant type than the source level.                                                                                                              |
| `levelFailedInSandbox`                            | A level node references a production-only level, which will fail when the workflow runs in a sandbox environment.                                                                                                                   |
| `levelNameEmpty`                                  | An applicant-level node has no level name assigned.                                                                                                                                                                                 |
| `levelNotFound`                                   | A level node references a level that does not exist among the configured levels.                                                                                                                                                    |
| `levelReadOnly`                                   | A level node references an inactive, read-only level, which may not be allowed depending on the client's read-only-level limitations.                                                                                               |
| `levelTypeMismatch`                               | A level node references a level whose type is neither standalone nor actions, and so cannot be used inside a workflow.                                                                                                              |
| `missingLevelsForTransition`                      | An action workflow references levels for its transitions that do not exist in the default (standard) workflow it transitions to.                                                                                                    |
| `multipleOutEdgesNotSupported`                    | A node type that permits only a single outgoing edge has more than one.                                                                                                                                                             |
| `nodeHasNoActions`                                | An action node carries an empty action list and therefore performs no action.                                                                                                                                                       |
| `nodeLevelMissingInStandard`                      | An action transition targets a level that is absent from the standard workflow.                                                                                                                                                     |
| `nodeTypeNoConditions`                            | A node type that does not support conditions has an outgoing edge that carries one.                                                                                                                                                 |
| `notesApplicantActionTargetInActionWorkflowsOnly` | A notes action with an applicant-action target is used in a default (non-action) workflow.                                                                                                                                          |
| `outEdgeRequired`                                 | A branching (exclusive-choice) node has no outgoing edges.                                                                                                                                                                          |
| `questionnaireMissing`                            | An action-questionnaire expression references a questionnaire that none of the preceding levels collects, so the referenced answers will never be present.                                                                          |
| `standardLevelsInStandardWorkflowsOnly`           | A standalone applicant level is used inside an action workflow, where only action levels are allowed.                                                                                                                               |
| `standardWorkflowDoesNotExist`                    | An action transition references a level, but no published standard workflow exists to validate the transition against.                                                                                                              |
| `syntaxError`                                     | A condition failed to compile; the underlying compiler error message is included in the notice.                                                                                                                                     |
| `tagDoesNotExist`                                 | A tags action references a tag that does not exist.                                                                                                                                                                                 |
| `tagListEmpty`                                    | A tags action defines neither tags to add nor tags to remove.                                                                                                                                                                       |
| `tagsApplicantActionTargetInActionWorkflowsOnly`  | A tags action with an applicant-action target is used in a default (non-action) workflow.                                                                                                                                           |
| `terminalNodeOutEdgesNotAllowed`                  | A terminal node (such as an applicant transition) has outgoing edges, which terminal nodes do not allow.                                                                                                                            |
| `unknownRejectionTag`                             | A final-rejection node references a review button (rejection tag) that does not exist.                                                                                                                                              |
| `unsupportedProperty`                             | A deprecated property is used in an expression; a supported replacement property is suggested in its place.                                                                                                                         |
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall