Skip to main content
Glama

update_workflow

Batch XML mutations on a workflow with optional progressive disclosure.

XML tags: <add_node type="..." name="alias" label="Human Readable Title" after="node-or-alias" operation="..." key="val" /> after= supports "node:handle" syntax for multi-output nodes, e.g. after="conditional:true" or after="iteration:loop" <add_edge from="alias-or-id" to="alias-or-id" handle="source-handle-id" /> handle is REQUIRED for multi-output nodes (iteration: loop|done, switch: case values, conditional: true|false). Output handles are returned by include_operations and shown in get_workflow XML. For iteration nodes: add a loop-back edge from the last body node TO the iteration node to mark which body node output to aggregate into collected_results. Example: <add_edge from="body-node" to="iteration-node" /> <add_edge from="integration-node" to="agent-node" type="tools" /> — TOOL-PROVIDER wiring: instead of dataflow, the source node's operations become callable agent tools (e.g. a linear node exposes linear__create_issue). Then set the operation allowlist: <update_config id="integration-node" agent_tool_operations='["create_issue","list_issues"]' /> (operation names from include_operations; invalid names are rejected with the valid list). The agent also gets an auto-included {provider}__lookup_options tool for ID fields. Provider-wired nodes do NOT execute in the flow and cannot also feed dataflow consumers, and cannot have a trigger operation selected (either-or — use a separate node per role); they still need credentials (set_credentials) for the agent to call their tools. Use this whenever an AI agent should ACT on a service (create/update/search) rather than a fixed pipeline step. Provider edges appear as type="tools" in get_workflow XML. Rule of thumb: deterministic steps with known inputs → dataflow pipeline; open-ended instructions where the agent picks actions and arguments → provider wiring. When the request is UNDERSPECIFIED (a goal and the services involved but not the exact steps, fields, or branching), PREFER an agent with the relevant integration node(s) wired as tool providers over guessing a rigid pipeline — the agent resolves the specifics at runtime and degrades far more gracefully than a hardcoded flow built on assumptions. Keep its input minimal too: wire any trigger STRAIGHT into the agent rather than a trigger->node->...->agent chain of fetch/transform nodes — the agent fetches itself. The AGENT node's built-in chat (streaming, history) shows in the Interface tab by default — set show_in_interface="false" only when the user explicitly asks to hide it (the chat is also the Test Run surface), and never build a custom chat interface component. Prefer the agent node for open-ended "act on my behalf" work over a one-shot LLM integration node. The agent runs a plain LLM or a full agentic HARNESS — Claude Code/Codex/OpenCode/OpenClaw/Hermes, each a CLI agent with its own built-in tools in a sandbox — set via the agent node model; these are agent models, NOT standalone node types (there is no hermes/codex node). GitHub providers can also MOUNT repos into the agent sandbox: <update_config id="github-node" agent_sandbox_repos='["owner/repo"]' /> — entries are "owner/repo" strings or {"repo": "owner/repo", "branch": "dev"} objects; each is cloned with push access at run start; the agent edits/pushes via execute_bash and opens PRs with github__create_pull_request. RARELY, when an agent must call an API that has NO NoClick node from its shell, request sandbox env vars by declaring their NAMES: <update_config id="agent-node" agent_env_requested='["STRIPE_KEY"]' /> (names only — the user provides values, which become a credential you can never read). Prefer a provider or HTTP Request node; only use env vars when no node exists for the API. <add_edge from="trigger-node" to="agent-node" /> — TRIGGER wiring: a trigger wired into an agent, directly or through if/else / switch routing, delivers its fired event as part of the agent's user turn automatically. Do NOT template trigger references into the agent message — it holds standing instructions; multiple triggers can feed one agent and only the fired one delivers. Channel triggers (Telegram/Slack message, alarms) also auto-supply their chat/thread id as the conversation key (per-chat history). For replies into the channel, wire the same service as a tools provider and allowlist its send operations. Trigger choice: the trigger-* nodes each create a NEW NoClick-hosted entry point (trigger-webhook a URL, trigger-email a name@noclick.email inbox, interface-form a public form, trigger-cron a schedule, trigger-run a manual button) and do NOT read the user's existing accounts. For something they already own ("my inbox/Slack/calendar/sheet"), use that integration's OWN trigger operation instead (its x-is-trigger op, e.g. automation-gmail poll_for_new_emails); reserve trigger-* for a genuinely new endpoint. <update_config id="alias-or-id" key="val" /> <update_config id="alias-or-id" field="field_name">large value</update_config> <set_credentials id="alias-or-id" credential_type="credential-uuid" /> <disable_node id="alias-or-id" /> <enable_node id="alias-or-id" /> <mock_node id="alias-or-id" output='{"key":"val"}' /> <mock_node id="alias-or-id">{"key":"val"}</mock_node> <unmock_node id="alias-or-id" /> <update_settings id="alias-or-id" retryOnFail="true" maxTries="3" waitBetweenTries="1000" onError="stopWorkflow" /> update_settings fields: retryOnFail (true|false), maxTries (2-5), waitBetweenTries (0-5000 ms), onError (stopWorkflow|continueRegularOutput|continueErrorOutput), alwaysOutputData (true|false), executeOnce (true|false), notes (free text). All fields are optional — only provided fields are updated. <patch_config id="alias-or-id" field="field_name">unified diff</patch_config> patch_config format (simplified unified diff): @@ anchor_line (locates position in existing code), -old_line (remove), +new_line (add), (space)context_line (unchanged). Example: @@ function App() / - return old / + return new <remove_edge from="..." to="..." handle="optional-handle" /> <remove_node id="..." /> <add_sticky_note name="alias" after="node-a" before="node-b" color="8">markdown content</add_sticky_note> <add_sticky_note name="alias" near="node-a,node-b" direction="above" color="8">markdown content</add_sticky_note> add_sticky_note positioning modes: cover (after+before spans bounding box between two nodes), near (near+direction places adjacent to node group). Anchor params are persisted so sticky notes reposition automatically when nodes move via autolayout. color=0-8 (default 8=black).

Reserved attrs per tag: add_node(type, name, label, after, operation), add_edge(from, to, handle, type), remove_edge(from, to, handle), remove_node(id), update_config(id, field), set_credentials(id), disable_node(id), enable_node(id), mock_node(id, output), unmock_node(id), update_settings(id, retryOnFail, maxTries, waitBetweenTries, onError, alwaysOutputData, executeOnce, notes), patch_config(id, field), add_sticky_note(name, after, before, near, direction, color, width, height). All other attrs are config.

name= on add_node is a local alias usable in from/to/after/id within the same batch.

Dynamic option suffixes in update_config: key__fuzzy="query" - auto-resolve dynamic field by fuzzy match (sets value if 1 match) key__search="query" - preview matching options without setting value key__search_limit="N" - limit search results (default 10, max 50) operation__fuzzy="query" - fuzzy match operation by name or description (auto-sets if 1 match)

Flags:

  • include_operations: returns available operations for each added node type (+ output_handles for multi-output nodes, + per-operation output_schema from past runs showing reference paths)

  • include_configs: returns config schemas for nodes where operation was set (includes credentials)

  • include_dynamic_options: auto-load first-level dynamic field options for touched nodes

Processing order: add_node → add_edge → add_sticky_note → update_config → patch_config → set_credentials → disable/enable → mock/unmock → update_settings → resolve dynamic options → remove_edge → remove_node

IMPORTANT — Sticky note best practice: After building or modifying a workflow, ALWAYS add covering sticky notes to label each major section. Use cover mode (after+before) with a short markdown title only (e.g. '## Data Processing'). For complex workflows, add additional nearby sticky notes with descriptive content explaining the section. This makes workflows self-documenting and easy to understand at a glance.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "workflow_id": "<workflow_id>",
      "updates_xml": "<updates_xml>"
    },
    "name": "update_workflow"
  }
}

Input Schema

NameRequiredDescriptionDefault
updates_xmlYes
workflow_idYes
idempotency_keyNo
include_configsNo
include_operationsNo
dynamic_options_limitNo
include_dynamic_optionsNo

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A3.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations (readOnlyHint=false, idempotentHint=false) already signal mutation, and the description adds substantial context beyond them: an explicit deterministic processing order, batch-scoped alias semantics, rejection behavior for invalid operation names, and provider-node constraints (cannot also feed dataflow, needs credentials). It does not explain idempotency_key behavior or reversibility of removals, which is the main behavioral gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Headers and a stated processing order give it usable structure and the first line is front-loaded. However, the "Reserved attrs per tag" block largely duplicates the per-tag syntax already presented, add_sticky_note is documented twice, and long passages on agent harnesses and sandbox repos are tangential to invoking this tool — significant avoidable bulk in an already long definition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return values need no prose, and the definition covers XML syntax, flags, and ordering thoroughly for a 7-parameter mutation tool. Missing pieces are the unexplained idempotency_key and dynamic_options_limit parameters, which an agent will otherwise have to guess at.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must carry the parameter load. It does explain include_operations, include_configs, and include_dynamic_options under "Flags", but workflow_id, updates_xml (only implicitly documented via the tag reference), idempotency_key, and dynamic_options_limit receive no direct explanation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Opens with a precise verb+resource statement: "Batch XML mutations on a workflow", which tells an agent this tool edits workflow structure rather than metadata (update_workflow_metadata) or reading (get_workflow). Scope and action are unambiguous, but the definition never explicitly names a sibling or contrast case, so an agent must infer the boundary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Guidance is unusually rich for when to use which construction approach — the "deterministic steps → dataflow pipeline; open-ended instructions → provider wiring" rule of thumb, the trigger-* vs existing-integration trigger advice, and the mandatory sticky-note best practice. It stops short of tool-selection guidance (e.g. when to prefer update_workflow over create_workflow or validate_workflow), so coverage is strong for design decisions but not for routing among siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.