Something that surprised me while profiling token usage on agentic n8n workflows: the tool definitions attached to an AI Agent node aren’t a one-time cost. The LLM is stateless, so on every turn the full schema of every connected tool (name, description, JSON parameter spec) gets re-serialized into the prompt and billed again — not just on the first call.
A few numbers from our own runs (we build AI tooling, so I instrument this obsessively):
- 4 tools wired into one Agent node added ~3,200 input tokens per turn, re-billed on every loop of the agent — not once.
- Tool results (the JSON an executed tool hands back) were ~34% of total input tokens over a multi-step run — often bigger than the user message and the tool schemas combined.
- Our input:output ratio landed around 1.9:1 — we paid for almost 2× as many input tokens as the model generated, and most of that input was tool plumbing, not conversation.
Things that actually moved the number for us:
- Trim tool descriptions. A verbose description on a tool attached to every agent run is a per-turn tax. Terse-but-clear beats a paragraph.
- Don’t attach tools “just in case.” Five rarely-used tools on an Agent node cost the same per turn as five heavily-used ones.
- Watch tool-result size. If a tool returns a big JSON blob and the agent needs two fields, trim before it re-enters context.
- Short agent loops help twice: fewer turns and the re-billed schema cost is paid fewer times.
Two things I’m genuinely curious about from people running bigger n8n agent setups:
- Has anyone measured whether the MCP Client Tool node’s schema is heavier per-turn than native tool nodes?
- Do you cap tools-per-Agent-node, or lean on sub-workflows/routing to keep each agent’s toolset small?
Disclosure: I work on an AI-tooling studio, so I’m biased toward measuring this — happy to share how we instrument it if useful.
A few additional things that helped us reduce token usage:
- We split one “super agent” with 12+ tools into 3 specialized agents behind a router. Each agent only receives the tools it actually needs, which noticeably reduced prompt size and improved tool selection.
- Instead of returning complete API responses, our tools now return only the fields the LLM needs (for example,
property_name, price, and availability instead of the full JSON). That alone cut thousands of tokens over longer conversations.
- We moved long business rules and static instructions out of the system prompt and into a vector store so they’re retrieved only when relevant.
- We also cache expensive lookups. If the same query comes up again, the workflow reuses the result instead of invoking the tool and injecting another large payload into the context.
Regarding MCP, from what I’ve seen the overhead depends more on the tool schema exposed by the MCP server than on MCP itself. If the server exposes many tools or verbose JSON schemas, the token cost can grow quickly. It would be interesting to see benchmarks comparing the same tools implemented as native n8n nodes versus MCP.
We’ve also started treating token cost per successful task as a KPI alongside latency and accuracy. It’s been a surprisingly useful metric when deciding whether to add another tool or refactor an agent into smaller, specialized workflows.
Great breakdown. One thing worth adding for n8n specifically: if you’re on Anthropic models, the AI Agent node’s HTTP options let you set prompt caching headers, and stable tool schemas (unchanging name/description/params across turns) are exactly what benefits most from cache_control breakpoints - you pay full price once, then a fraction on subsequent turns as long as the tool block doesn’t change. So instead of just trimming descriptions, freezing the tool set order and wording per session (even if you conditionally disable unused tools rather than omitting them) can let caching kick in. For OpenAI models n8n doesn’t expose this directly, but keeping the system message + tool definitions byte-identical across calls still helps since OpenAI auto-caches repeated prefixes over ~1024 tokens. Worth checking your LLM provider’s caching docs alongside the schema-trimming tips above.
1 „Gefällt mir“