Description

n8n-nodes-tendem

The n8n community node for Tendem — a hybrid
AI + human task service. You submit a task in plain English, Tendem’s orchestrator
scopes it in a chat and quotes a transparent price, and once a human approves
the spend, a vetted expert executes it and returns verified results as markdown
plus files.

Use it when a workflow hits work an automation can’t reliably nail: research and
competitive analysis, copywriting and editing, design review, data cleaning, list
building, anything needing real judgement. Don’t use it for quick
general-knowledge lookups, and note that Tendem declines data-scraping work by
policy.

• Installation
• Credentials
• One node, five resources
• The Expert resource: the high-level surface
• Operations
• Approving a task spends real money
• Worked example
• Polling without a busy loop
• Attaching input files
• Compatibility

Installation

Go to Settings → Community nodes → Install, enter n8n-nodes-tendem, accept
the risk prompt, and install. A Tendem node appears in the node panel.

Other setups are covered in n8n’s own guide: Installing community
nodes.

Credentials

The node talks to Tendem’s hosted MCP server over streamable HTTP. Authentication
is an API key, sent as Authorization: ApiKey .

1. Sign in at agent.tendem.ai.
2. Go to agent.tendem.ai/mcp, open the **Agent
builders tab, and click Generate API key**.
3. In n8n: Credentials → New → Tendem API, paste the token, save.

Use n8n’s Test button on the credential — it performs a real MCP initialize
handshake against the endpoint, so a bad key fails immediately rather than at the
first workflow run.

| Field | Default | Notes |
|—|—|—|
| API Key | — | Required. Stored encrypted by n8n; never put it in a node parameter or an HTTP Request node. |
| MCP Endpoint | https://mcp.tendem.ai/mcp?utmhash=83dad40a52 | Overridable, but only change it to target a non-production Tendem deployment. The utmhash is n8n channel attribution. |

Tendem also supports interactive OAuth, which is what the Claude Code / Cursor /
Gemini plugins use. n8n workflows run unattended, so this node deliberately does
API keys only.

One node, five resources

The package installs a single Tendem node. Its Resource selector splits the surface in
two layers:

• Expert — the high-level surface. Five lifecycle operations with the delegation

choreography built in; the one to reach for first, and the one to hand to AI Agents.

• Task / Chat / Account / File — the raw protocol surface. All 11 Tendem MCP tools as

granular operations, for workflows that want full control over each step.

The Expert resource: the high-level surface

Each operation returns an outcome envelope — branch on outcome, everything else rides
along as data:

| Operation | Spends money | Outcomes it returns |
|—|—|—|
| Delegate | no | created (with the task_id everything else needs) |
| Check & Advance | no | question, quote, result, pending, topup_required, closed |
| Reply | no | same as Check — it answers, then keeps advancing |
| Approve (Spends Money) | yes | approved, quote (refused, nothing charged), topup_required |
| Wait for Result | no | result (markdown + file URLs), pending, quote, question |

What the Expert resource does for you, so neither workflows nor agents have to:

• Waiting is server-side. Polling long-polls on Tendem’s side and honours its pacing hints;

pending is always resumable — call again with the same task_id.

• The chat choreography is built in. await_input becomes a question outcome with

Tendem’s text; Reply answers at the live conversation offset and absorbs the race the
protocol allows.

• File upload is one field. Name the binary properties in Input Binary Fields on

Delegate; the node mints the upload URL, does the host-swapped PUTs, and announces the
files to the expert.

• Money is one operation with a policy. Approve is the only spending path, and its

Approval Policy says where consent comes from: Never (default — quotes stay data),
Under Max Price (auto-approve at or under a cap you set), From Decision Field
(a boolean driven by any upstream approval — Slack, form, IF), or Always. Whatever the
policy, the engine re-reads the live quote at approval time and never pays a price it
cannot parse.

As an AI Agent tool, this is the resource to attach: each operation’s description tells the
model when to reach for it, so no system-prompt choreography is needed. Give an agent
Delegate + Check + Reply and it can drive a task end to end without ever being able to spend;
add Approve with a policy only when the workflow’s spend rules are settled.

Example workflow: self-driving delegation

examples/self-driving-delegation.json — import it
via the editor’s ⋯ → Import from URL with the raw link:

https://raw.githubusercontent.com/Toloka/n8n-nodes-tendem/main/examples/self-driving-delegation.json

A chat message delegates the work, then a loop drives the task to completion **without an LLM in
the waiting path**: Check & Advance long-polls server-side and loops on pending for free; a
Text Classifier decides structurally whether Tendem’s message is a scoping question (answered by
a small agent, replied automatically) or already the final answer (Tendem answers trivial briefs
free in the chat — the run then ends with it); quotes park at an Approve node whose policy ships
as Never — flip it to Under Max Price or wire From Decision Field to a human approval to
let it spend. After import, select your Tendem credential on the four Tendem nodes and an
LLM credential on the model node.

Operations

The raw protocol surface, one operation per Tendem tool:

| Resource | Operation | Tendem tool | Spends money |
|—|—|—|—|
| Task | Create | create_task | no |
| Task | Get | get_task | no |
| Task | Get Contract | get_contract | no |
| Task | Approve (Spends Money) | approve_task | yes |
| Task | Get Cancel URL | cancel_task | no |
| Task | Get Result | gettaskresult | no |
| Task | List | list_tasks | no |
| Task | Wait for Change | get_task (long-poll) | no |
| Chat | Read | read_chat | no |
| Chat | Send | send_message | no |
| Account | Get | get_account | no |
| File | Get Upload URL | getfileupload_url | no |

Every response is passed through as JSON on the item, including Tendem’s guidance
envelope — nextaction, pollafterseconds, polltimeout_seconds,
guidance. Branch on next_action, not on the raw status; Tendem treats it
as authoritative. The statuses you’ll see are ACTING, LISTENING,
NEEDS_REPAIR, CLOSED (terminal, but the result is still fetchable) and
DELETED.

Note on Get Cancel URL

cancel_task does not cancel anything. It returns a Tendem UI URL where a
person can cancel. Send them there.

Approving a task spends real money

Approval charges the Tendem account, so the node treats it as a distinct,
deliberate act rather than a step that can happen on the way to something else.
Four things stand in the way, and they are structural, not documentation:

1. Approval is its own operation. approve_task is reachable only from
Task → Approve and Expert → Approve. A workflow author has to add that node
on purpose.
2. Per-operation capability guard. Each operation executes against an
allowlist naming the Tendem tools it may call. The two Approve operations are
the only rows containing approve_task; every other operation is refused
before any HTTP request is made. Creating a task, polling one, or reading
its chat cannot approve it even if the code above them were wrong.
3. Confirm Spend must be on. The Approve operation refuses while the
Confirm Spend toggle is off. Drive it from an expression if a human
decision upstream — an n8n Wait-for-form, a Slack approval, an email gate —
should decide. It is evaluated per item, so confirming one item never
approves another.
4. A price must be supplied. Approve requires the quoted price, which means
the amount being committed had to be read before it could be committed.

The node also never tops up and never retries. Insufficient balance comes back as
data, not an exception, so you can route on it:

{ "approved": false, "spendBlocked": true, "topupUrl": "https://…", "reason": "insufficient_balance" }

Send topupUrl to the user. That link is task-bound: paying it tops up and
auto-approves this task, so don’t call Approve again afterwards.

On success you get approved: true, spendBlocked: false, topupUrl: null.

Using the node as an AI Agent tool

The node is available to n8n AI Agents (usableAsTool), under the same trust
model as any paid-service node: wiring a credential is the consent to spend
against it, exactly as with an LLM node billing an API key. The difference is
that Tendem spend can never be a side effect — even for an agent, the Approve
operation demands an explicit confirmSpend: true and the quoted price passed
through, so every charge is a deliberate, named-amount decision that shows up in
the execution log. Creating, scoping, chatting, and reading results are free, so
an agent can drive the whole task lifecycle and leave the one paid click to
whatever policy your workflow sets — its own judgment, a spend cap expression,
or a human gate upstream.

Worked example: research brief, end to end

A workflow that submits a brief, surfaces the quote to a human, and only then
spends. Nine nodes:

Manual Trigger
  → Tendem: Task → Create
  → Tendem: Task → Wait for Change            (until the quote is ready)
  → Tendem: Task → Get Contract               (scope + price)
  → Slack / Email: send the scope and price to a human
  → Wait for approval (n8n Wait node with a form / webhook resume)
  → IF: did the human approve?
      true  → Tendem: Task → Approve          (Confirm Spend = the human's answer)
              → Tendem: Task → Wait for Change  (until the work is done)
              → Tendem: Task → Get Result
      false → Tendem: Task → Get Cancel URL   (and send it to the human)

1. Task → Create. Pass the requester’s own words through verbatim. Don’t
pre-interrogate them and don’t rewrite the brief — Tendem’s orchestrator does the
scoping and asks follow-up questions over chat.

| Parameter | Value |
|—|—|
| Name | Competitor research for EU freight brokerage |
| Description | Research the top 5 competitors in EU freight brokerage and summarise their pricing models in a one-page brief. |
| Conversation ID | (optional) {{ $execution.id }} — lets Tendem correlate several tasks from one run |

Output carries taskid and lastseen_offset. Nothing is charged yet.

2. Task → Wait for Change. Task ID {{ $json.task_id }}. This blocks until
Tendem needs you. When nextaction comes back awaitinput, Tendem asked a
scoping question: read it with Chat → Read and answer with Chat → Send,
then wait again. Send figures out the conversation position on its own (that’s
the “Resolve Offset Automatically” toggle, on by default), so there is no offset
to thread through the workflow. When nextaction is awaituser_approval, the
quote is ready.

3. Task → Get Contract. Returns the scope Tendem committed to
(task_description, criteria) and the price. Scope is ready before the price
is, so a contract can legitimately come back with price: null — that means keep
waiting, not approve at zero.

4–6. Show a human the scope and the price, and wait for an answer. This is
the part the node cannot do for you and deliberately will not fake. Any n8n
approval mechanism works: a Wait node with a form, a Slack interactive message, a
webhook.

7. Task → Approve.

| Parameter | Value |
|—|—|
| Task ID | {{ $json.task_id }} |
| Name | {{ $json.name }} |
| Price | {{ $json.price }} — the number the human was shown |
| Confirm Spend | {{ $json.humanApproved === true }} |

Route spendBlocked === true to a branch that sends the human topupUrl.

8. Task → Wait for Change again, until nextaction is fetchresult or
done. Expert work takes minutes to hours, so set Max Rounds to what you’re
willing to hold an execution open for (each round is at most 30 seconds) and
handle tendemWait.timedOut === true by re-entering the wait on a schedule
rather than by raising the cap.

9. Task → Get Result. Returns the result markdown plus pre-signed download
URLs for any files. Fetch those with an HTTP Request node if you need the bytes.

Polling without a busy loop

Wait for Change does not spin. Each round is a single
gettask(taskid, waitforchange_seconds=N) call, and the server holds the
request open until the task actually changes — no client-side interval, no
repeated requests while nothing is happening.

| Parameter | Default | Range |
|—|—|—|
| Wait for Change (Seconds) | 30 | 5–30 (30 is the Tendem API’s ceiling) |
| Max Rounds | 20 | 1–240 |

The round count is a hard cap. When the budget runs out the node emits the latest
snapshot with:

{ "tendemWait": { "settled": false, "timedOut": true, "rounds": 20 } }

Branch on tendemWait.timedOut and re-enter the wait later. At the defaults, one
node holds an execution open for at most ten minutes.

There’s a backstop underneath: if a round returns faster than the server could
plausibly have blocked — a proxy that doesn’t support long-polling, say — the node
sleeps before the next one, honouring Tendem’s pollafterseconds hint. A
misbehaving endpoint degrades to a paced poll, never to a hot loop.

Transient failures are absorbed too: read operations retry a
TEMPORARILY_UNAVAILABLE, a 5xx, or a dropped connection with backoff (up to 5
attempts) instead of failing the workflow, so an hours-long expert wait survives
the blips it will inevitably see. Operations that write — Create, Send, Approve —
are never retried, because repeating them could duplicate a task, a message, or
a charge.

Attaching input files

Uploads need a task_id, so they can only happen after Create.

1. File → Get Upload URL with the task ID. You get a short-lived, folder-level
pre-signed URL.
2. For each file, build the PUT URL from the folder URL and upload with an HTTP
Request node:
– swap the host from .dfs.core.windows.net to .blob.core.windows.net,
– append the file name to the path before the query string —
/?,
– PUT the raw bytes with the header x-ms-blob-type: BlockBlob.

All three matter: a PUT to the URL exactly as returned fails with HTTP 400.
Keep names simple; avoid spaces. Subpaths like data/input.csv are fine.
3. Chat → Send naming the files you uploaded, e.g.
I've uploaded brief.pdf and data/input.csv for this task. Tendem waits for
this message; without it the expert never sees the files.

If the brief already references the files, mention them in the Create description
and promise them. Tendem may ask for them before your upload finishes — that race
is expected, and the confirming chat message settles it.

Compatibility

• n8n API version 1, node type version 1
• Upgrading from 0.2.x: the package now installs a single node. Workflows built with the

Tendem Expert node keep working unchanged — it is that node that survived (same type id,
now displayed as “Tendem”), with the raw protocol surface folded in as the Task / Chat /
Account / File resources. Workflows built with the old raw tendem node type must be
re-created from those resources.

• Node.js >= 20.19
• No runtime dependencies. The MCP client is implemented in this package, in

~350 lines, against the Streamable HTTP
transport
spec — so there is nothing to audit but this repository.

Support

• Issues:
• Email:

License

MIT © Toloka AI BV