Separating Intelligence from Execution: A Workflow Engine for the Model Context Protocol

Abhinav Singh Parmar

cs.DCMar 13, 2026

Separating Intelligence from Execution: A Workflow Engine for the Model Context Protocol

Authors: Abhinav Singh Parmar

Organizations: A Preprint

Abstract

Large Language Model (LLM) agents increasingly interact with external systems through tool-calling protocols such as the Model Context Protocol (MCP). In prevailing architectures, the agent must reason about every tool invocation in every session, consuming tokens proportional to the number of actions performed--even when the task has been solved before. We present the MCP Workflow Engine, a novel MCP-native orchestration layer that decouples intelligence (deciding what to do) from execution (carrying it out). An agent reasons once to produce a declarative workflow blueprint--a JSON document specifying a directed sequence of MCP tool calls with parameterized templates, loops, parallel branches, and data piping. Subsequent executions are triggered by a single run_workflow tool call, consuming one invocation's worth of tokens regardless of the blueprint's internal complexity. We formalize the MCP Mediator architectural pattern--an MCP server that simultaneously acts as a client to downstream MCP servers--and implement it in TypeScript against the MCP SDK. We evaluate the engine on a production-scale Kubernetes CMDB synchronization task spanning 67 orchestrated steps across 2 MCP servers, 38 namespaces, 13 worker nodes, and 22 distinct resource types. The engine reduces per-execution token cost by over 99%, completes the full cluster graph--comprising 1,200+ nodes and 2,800+ relationships across 20 relationship types--in under 45 seconds, and achieves deterministic, idempotent execution with zero agent involvement at run time.

Figures & tables

System	LLM in exec.	Reusable artifact	MCP -native	Exec. cost/run
ReAct/Toolformer ( Yao et al., 2023 ; Schick et al., 2023 )	Yes	None	No	$O(N\cdot\bar{T})$
LangChain/CrewAI ( Chase, 2022 ; Moura, 2024 )	Yes	Chains (code)	No	$O(N\cdot\bar{T})$
AutoGen/MetaGPT ( Wu et al., 2023 ; Hong et al., 2023 )	Yes	Conversations	No	$O(N\cdot\bar{T})$
Airflow/Temporal ( Apache Software Foundation, 2015 ; Temporal Technologies, 2020 )	No	DAGs (code)	No	0 (no LLM)
TaskWeaver ( Qiao et al., 2023 )	Yes	Code	No	$O(N\cdot\bar{T})$
MCP Workflow Engine	No	JSON blueprints	Yes	$\mathbf{O(1)}$

Table 1: Comparison of orchestration approaches for multi-step tool-using tasks. We distinguish design cost (one-time) from execution cost (per-run).

N

= number of steps,

\bar{T}

= average tokens per step.

Figure 1: Three-layer architecture of the MCP Workflow Engine (MCP Mediator pattern). The engine is simultaneously an MCP server (upward, exposing workflow tools to agents) and an MCP client (downward, connecting to Kubernetes, Graph DB, and other downstream MCP servers).

Figure 2: Two-phase lifecycle. The LLM agent is involved only at design time (Phase 1). All subsequent executions are handled entirely by the Workflow Engine (Phase 2), consuming zero agent tokens.

Figure 3: The five step primitives ( call , loop , parallel , pipe , collect ) and their composition in the CMDB synchronization workflow.

Figure 4: Template resolution pipeline. The resolver performs multi-pass substitution, resolving loop variables and step references to produce a fully-resolved Cypher query.

Strategy	Behavior	Use Case
abort	Stop immediately on first failure	Critical pipelines
continue	Log error, skip step, proceed	Best-effort sync
retry	Retry up to $n$ times with backoff	Transient failures

Table 2: Error handling strategies.

Phase	Steps	Input	Output	Total
Tool discovery & planning	3	1,500	2,500	4,000
Cluster-scoped fetches	5	5,000	2,500	7,500
Namespace enumeration	1	500	1,200	1,700
Per-ns resource fetches (38 $\times$ 12)	456	228,000	45,600	273,600
Graph node creation loops	$\sim$ 800	400,000	80,000	480,000
Relationship creation (20 $\times$ 38)	$\sim$ 760	380,000	76,000	456,000

Table 3: Estimated token consumption: Agent-in-the-loop baseline.

Phase	Cycles	Input	Output	Total
Exploration (one-time)	$\sim$ 8 tool-calling	$\sim$ 12,000	$\sim$ 4,000	$\sim$ 16,000
Blueprint construction (one-time)	$\sim$ 15 reasoning	$\sim$ 30,000	$\sim$ 8,000	$\sim$ 38,000
Total design (one-time)	$\sim$ 23	$\sim$ 42,000	$\sim$ 12,000	$\sim$ 54,000
Execute (per run)	1 tool call	$\sim$ 100	$\sim$ 50	$\sim$ 150

Table 4: Token consumption: Workflow engine.

Runs ( $K$ )	Agent Total	Engine Total	Token Savings
1	1,246,800	54,150	95.7%
2	2,493,600	54,300	97.8%
5	6,234,000	54,750	99.1%
10	12,468,000	55,500	99.6%
50	62,340,000	61,500	99.9%
365	455,082,000	108,750	$\sim$ 99.98%

Table 5: Amortized token cost comparison over

K

executions. The engine’s cost is

54{,}000+K\times 150

Property	Value
Cluster name	atlas-prod (anonymized)
Worker nodes	13 ( node-alpha-01 through node-alpha-13 )
Namespaces	38 (platform-core, data-services, ml-workloads, …)
Resource types synced	22
Downstream MCP servers	2 (Kubernetes, Graph Database)
Graph database	Property graph (Cypher query language)

Table 6: Target cluster characteristics.

Phase	Description	Steps	Types
1. Cluster-scoped	Cluster node, 13 nodes, storage, PVs, roles, CRBs	8	call
2. Namespace-scoped	38 ns $\times$ 15 resource types	39	call , loop
3. Relationships	20 types linking resources	20	call
Total		67

Table 7: Workflow structure by phase.

Figure 5: CMDB graph schema produced by the workflow, showing 16 node labels and 20 relationship types. The Cluster node is the root, with Namespace and Node as primary children.

Metric	Value
Total execution time	$\sim$ 42 seconds
Top-level steps executed	67
Total MCP tool invocations (incl. loop iters)	$\sim$ 2,000+
Graph nodes created	1,200+
Graph relationships created	2,800+
Distinct relationship types	20

Table 8: Full-cluster CMDB sync execution metrics.

Metric	Single-Namespace	Full-Cluster
Namespaces	1	38
Blueprint steps	27	67
Resource types	8	22
Loop iterations	$\sim$ 138	$\sim$ 2,000+
Graph nodes	139	1,200+
Relationships	245	2,800+

Table 9: Scaling from single-namespace to full-cluster sync.

Configuration	Steps	Time	Errors	Notes
Full engine	67	42s	0	Baseline
No parallel execution	67	68s	0	+62% time
No template resolution	—	—	67	All steps fail
No error strategy ( abort )	67	38s	1 (halts)	First failure stops
No client pool routing	—	—	67	Cannot locate tools

Table 10: Component ablation study.

Domain	Example Workflow	Steps	Savings
Code-to-Graph Pipeline	Sync repo metadata to knowledge graph	$\sim$ 20	$>$ 95%
Incident Response	Correlate alerts $\to$ logs $\to$ deployments	$\sim$ 15	$>$ 95%
Security Auditing	Scan images $\to$ CVEs $\to$ running pods	$\sim$ 18	$>$ 95%
Customer Support	Triage $\to$ KB $\to$ CRM $\to$ classify $\to$ route	$\sim$ 10	$>$ 90%
Data Lineage	Trace source $\to$ transforms $\to$ dashboards	$\sim$ 12	$>$ 95%
Compliance Reporting	RBAC $\to$ over-perm. accounts $\to$ report	$\sim$ 25	$>$ 95%

Table 11: Cross-domain applicability of the workflow engine pattern.

Component	File	Lines	Purpose
Type definitions	types/workflow.ts	134	Blueprint, Step, Result types
Template resolver	engine/template-resolver.ts	82	JMESPath + dot-path resolution
Workflow engine	engine/workflow-engine.ts	216	Orchestration, validation
Call executor	engine/steps/call.ts	49	MCP tool invocation + retry
Loop executor	engine/steps/loop.ts	67	Collection iteration
Parallel executor	engine/steps/parallel.ts	52	Concurrent execution

Table 12: Implementation component inventory.

LLM Agent Tool Generation

See all 11 papers

Sep 20, 2026

MCPGen: Benchmarking LLMs on Executable MCPWorkflow Development

We study whether LLMs can produce executable workflow artifacts that remain consistent across graph structure, tool implementation, schema bindings, and runtime wiring. In this setting, correctness depends on cross-layer consistency: a workflow may be structurally plausible, yet still fail because tool implementations, schema bindings, or runtime execution do not align. Existing benchmarks largely evaluate these capabilities in isolation or rely on trajectory-level proxies, leaving open whether generated workflow artifacts execute end-to-end. We introduce MCPGen, an executable benchmark for Model Context Protocol (MCP) workflow development. MCPGen contains 100 self-contained MCP projects across 16 application domains and evaluates three diagnostic tasks: workflow reconstruction, tool creation, and backward-compatible workflow extension. We evaluate 11 representative LLMs in a single-turn foundation-model setting, assessing generated artifacts through static analysis, unit and integration tests, and process-isolated end-to-end execution. Models reach 88.5% on workflow reconstruction, but no model exceeds 57% end-to-end execution success. Per-tool unit-test pass rates reach 63.8%, while project-level integration success does not exceed 45%, suggesting that integration remains a major bottleneck even when isolated tool tests pass.

Yingxuan Yang, Jiaqi Liu, Lirui Guan +4

Shanghai Jiao Tong University Shanghai, China

LLM Evaluation LLM Code Generation LLM-Based Program Synthesis

Ask PDF

Jul 17, 2026

Scalable LLM Agent Tool Access in the Cloud

LLM agents increasingly rely on tool calling to act on external systems, and the Model Context Protocol (MCP) has quickly become its de facto interface. Operating MCP at cloud scale, however, becomes difficult. On the tool provider side, legacy services are not directly callable through MCP; the rapid protocol development also creates ongoing compatibility cost. On the agent side, the number of accessible tool is limited by the LLM context window and inference overhead; mounting a large tool set increases token usage and inference latency and can reduce task success rate. Moreover, for stateful MCP backends with multiple replicas, preserving session affinity increases client-side complexity. We present a cloud-scale gateway system for MCP service. It breaks the direct-connect model on the data plane and offloads legacy service integration, consolidating incompatible MCP variants, access control, tool recommendation, and session-aware routing to the gateway. Hybrid retrieval sustains 98% Top-15 recall; it scales agent tool access to 3,000+ with high tool selection accuracy, and reduces tool selection time by

8.9\times

and token usage by

23.8\times

, with low per-call overhead, stable under scale-out. Finally, we share the lessons learned from deploying the gateway system in production.

Mingxin Li, Enge Song, Yueshang Zuo +27

Nanjing University · Alibaba Cloud · Fudan University +3

LLM Tool Use Model Context Protocol Tool-Using Language Agents Tool Access Control for LLM Agents LLM Agent Routing

Ask PDF

May 9, 2026

MCP-Cosmos: World Model-Augmented Agents for Complex Task Execution in MCP Environments

The Model Context Protocol (MCP) has unified the interface between Large Language Models (LLMs) and external tools, yet a fundamental gap remains in how agents conceptualize the environments within which they operate. Current paradigms are bifurcated: Task-level planning often ignores execution-time dynamics, while reactive execution lacks long-horizon foresight. We present MCP-Cosmos, a framework that infuses generative World Models (WM) into the MCP ecosystem to enable predictive task automation. By unifying three disparate technologies, namely MCP, World Model, and Agent, we demonstrate that a "Bring Your Own World Model" (BYOWM) strategy allows agents to simulate state transitions and refine plans in a latent space before execution. We conducted experiments using two strategies, namely ReAct and SPIRAL with 2 planning models and 3 representative world models over 20+ MCP-Bench tasks. We observed improvements in Agent's environment interaction KPI such as tool success rate and tool parameter accuracy. The framework also offers new metrics such as Execution Quality to generate new insights about the effectiveness of world models compared to baseline.

Giridhar Ganapavarapu, Dhaval Patel

IBM, New York

LLM World Models World Models Latent World Models LLM Agent Planning

Ask PDF

Abstract

LLM Agent Tool Generation

Explore similar work

MCPGen: Benchmarking LLMs on Executable MCPWorkflow Development

Scalable LLM Agent Tool Access in the Cloud

MCP-Cosmos: World Model-Augmented Agents for Complex Task Execution in MCP Environments