VAST Data
AgentEngine & MCP
AdvancedRun, govern, and observe AI agents next to the data they reason over - with a shared MCP tool registry.
Why run agents next to the data
An agent isn't one model call - it's a loop that reasons, calls a tool, observes the result, and repeats (see Agentic AI). Almost every step touches data: a query, a function, a memory lookup. When the agent runs far from that data, every tool call crosses the network, latency compounds across dozens of steps, and the audit trail fragments across systems that don't share a log.
VAST's answer is to move the agent onto the data plane. AgentEngine is an agentic-AI runtime that runs natively inside DataEngine - the application-management layer of the VAST AI Operating System - so multi-agent workflows execute next to the data, with a built-in tool registry and unified audit instead of glue code and governance gaps.
Where the agent runs changes everything
An agent reasons over data on every step. Run it far away and each tool call crosses the network; run it next to the data and the call is local and audited.
Path to the data
5 hops
Governance
Gaps: each hop is a different log, owner, and trust boundary - hard to audit end to end.
Agent FAR from the data
Agent host (cloud VM)
agent runtime, separate from data
API gateway
auth, rate limits
Connector / ETL service
translates each request
Network egress
cross-region transfer + cost
Storage / data platform
the data finally lives here
Hop counts are illustrative of typical topologies, not a benchmark. AgentEngine is preview/roadmap.
AgentEngine: the four pillars
AgentEngine is organized around four pillars: a Runtime that deploys and checkpoints agents, a Studio for wiring them to tools and data, a Toolbox registry of shared MCP tools, and Observability for everything they do. Explore each below.
AgentEngine - the four pillars
The application-management layer of the VAST AI Operating System. Tap a pillar to see what it does and why it matters.
Deployment & Runtime
What it does
A Kubernetes-based runtime that deploys agents as containers, loads models into GPU memory, and checkpoints long-running agents so their memory and reasoning state survive failures.
Why it matters
Agents that run for hours can crash, get preempted, or hit a tool timeout. Checkpointing means a long task recovers from where it stopped instead of starting over - durability for autonomous work.
- Container deploy on Kubernetes
- Models loaded into GPU memory
- Checkpoint agent state (memory + reasoning)
- Recover long runs without losing progress
MCP & the shared Toolbox
The Model Context Protocol (MCP) is the open standard for connecting agents to tools. VAST exposes its data, metadata, functions, web search, and even other agents as MCP-compatible tools through AgentEngine's tool server - a native MCP registry built into the data platform, not a bolt-on. Every tool in the Toolbox is versioned, monitored, and reusable across agents and teams, so a connector built once becomes a governed building block rather than per-project glue.
The MCP Toolbox - one registry, many tools, many agents
VAST exposes data, functions, web search, and other agents as MCP-compatible tools. Each one is versioned, monitored, and reusable. Tap a tool to inspect the call.
versioned · monitored · reusable
Read tables, objects, and metadata exposed by the platform directly as an MCP tool - no separate connector to maintain.
vast.query(table='claims', where='status=open')
Used by: claims agent, BI agent, audit agent
Governance & observability for agents
Autonomous systems are only trustworthy if you can see and constrain them. Studio sets identity, access, and audit policy up front; the Toolbox versions and monitors every tool; and Observability captures what actually happened at runtime.
Identity & access
Set who an agent is and what it's allowed to reach before it runs - defined alongside the tools it can call, in Studio.
Access logs & tool metrics
Every tool call is logged with usage metrics, so you can answer which agent touched which data, and how often.
Chain-of-thought tracing
Capture the full prompt/response history and reasoning trace to debug why an agent took an action - not just that it did.
Feedback capture
Record outcomes and human feedback to evaluate and improve agents over time, kept with the run that produced them.
How it composes with DataEngine & the platform
AgentEngine doesn't stand alone. It runs inside DataEngine on the same platform that stores the structured and unstructured data, embeddings, and agent memory those agents reason over - so the runtime, the tools, and the data share one governance and storage plane.
Runtime
AgentEngine on DataEngine
Agents deploy as containers and execute on the data plane, close to what they read and write.
Hardware
NVIDIA & CNode-X
An NVIDIA partnership and CNode-X - storage running on GPU servers - put compute and data on the same nodes.
Memory & tools
Data, embeddings & MCP
Durable agent memory and vector search live on the same platform the Toolbox exposes as MCP tools.
Maturity & what to watch
Be precise with customers on maturity. AgentEngine and its MCP Toolbox were announced for the second half of 2025 and should be positioned as preview / roadmap - not generally available. Sell the architecture and direction, and confirm current availability before committing to a deployment.
AgentEngine runtime
Preview / roadmapMCP Toolbox registry
Preview / roadmapOpen-source example agents
One per month, 12 months- Watch for GA dates on the runtime, Studio, and Toolbox before positioning anything as production-ready.
- VAST pledged to open-source one example agent every month for 12 months - a useful signal of capability and cadence.
- Track how the offering tracks the evolving MCP spec, especially identity, audit, and async operations.
VAST reports AgentEngine as part of the VAST AI Operating System, announced for 2H 2025 and tied to an NVIDIA partnership and CNode-X. Maturity and availability per VAST announcements; confirm current status with VAST before deployment.
Related
AgentEngine is the platform side of the agent story. For the concepts - the agent loop, context and memory, tool use, and orchestration - start with Agentic AI.