DataRobot and Nebius have partnered to introduce AI Factory for Enterprises, a joint solution designed to accelerate the development, operation, and governance of AI agents. This platform allows agents to reach production in days, rather than months.
AI Factory for Enterprises provides a scalable, cost-effective, governed, and managed enterprise-grade platform for agents. It achieves this by combining DataRobot’s Agent Workforce Platform: the most comprehensive, flexible, secure, and enterprise-ready agent lifecycle management platform, with Nebius’ purpose-built cloud infrastructure for AI.
Our partnership
Nebius: The purpose-built cloud for AI
The challenge today is that general-purpose cloud platforms often introduce unpredictable performance, latency, and a “virtualization tax” that cripples continuous, production-scale AI.
To solve this, DataRobot is leveraging Nebius AI Cloud, a GPU cloud platform engineered from the hardware layer up specifically to deliver the bare-metal performance, low latency, and predictable throughput essential for sustained AI training and inference. This eliminates the “noisy-neighbor” problem and ensures your most demanding agent workloads run reliably, delivering predictable outcomes and transparent costs.
Nebius’ Token Factory augments the offering by providing a pay-per-token model access layer for key open-source models, which customers can use during agent building and experimentation, and then deploy the same models with DataRobot when running the agents in production.
DataRobot: Seamlessly build, operate, and govern agents at scale
DataRobot’s Agent Workforce Platform is the most comprehensive Agent Lifecycle Management platform that enables customers to build, operate, and govern their agents seamlessly.
The platform offers two primary components:
- An enterprise-grade, scalable, reliable, and cost-effective runtime for models and agents, featuring out-of-the-box governance and monitoring.
- An easy-to-use agent builder environment that enables customers to seamlessly build production-ready agents in hours, rather than days or months.
Comprehensive enterprise-grade runtime capabilities
- Scalable, cost-effective runtime: Features single-click deployment of 50+ NIMs and Hugging Face models with autoscaling or deploy any containerized artifacts via Workload API (both with inbuilt monitoring/governance), optimized utilization through endpoint level multi-tenancy (token quota), and high-availability inferencing. You can deploy containerized agents, applications or other composite systems built using a combination of say LLMs, domain specific libraries like PhysicsNemo, cuOpt etc., or your own proprietary models, with a single command using Workload API.
- Governance and monitoring: Provides the industry’s most comprehensive out-of-the-box metrics (behavioral and operational), tracing capabilities for agent execution paths, full lineage/versioning with audit logging, and industry-leading governance against Security, Operational, and Compliance Risks with real-time intervention and automated reporting.
- Security and identity: Includes Unified Identity and Access Management with OAuth 2.0, granular RBAC for least-privilege access across resources, and secure secret management with an encrypted vault.
Comprehensive enterprise-grade agent building capabilities
- Builder tools: Support for popular frameworks (Langchain, Crew AI, Llamaindex, Nvidia NeMo Agent Toolkit) and out-of-the-box support for MCP, authentication, managed RAG, and data connectors. Nebius token factory integration enables on-demand model use during the build.
- Evaluation & tracing: Industry-leading evaluation with LLM as a Judge, Human-in-the-Loop, Playground/API, and agent tracing. Offers comprehensive behavioral (e.g., task adherence) and operational (latency, cost) metrics, plus custom metric support.
- Out-of-the box production readiness: Enterprise hooks abstract away infrastructure, security, authentication, and data complexity. Agents deploy with a single command; DataRobot handles component deployment with embedded monitoring and governance at both the full agent and individual component/tool levels.
Build and deploy using the AI Factory for Enterprises
Want to take agents you have built elsewhere, or even open source industry specific models and deploy them in a scalable, secure and governed manner using the AI Factory? Or would you like to build agents without worrying about the heavy lifting of making them production ready? This section will show you how to do both.
1. DataRobot STS on Nebius
DataRobot Single-Tenant SaaS (STS) is deployed on Nebius Managed Kubernetes and can be backed by GPU-enabled node groups, high-performance networking, and storage options appropriate for AI workloads.For DataRobot deployments, Nebius is a high-performance low cost environment for agent workloads. Dedicated NVIDIA clusters (H100, H200, B200, B300, GB200 NVL72, GB300 NVL72) enable efficient tensor parallelism and KV-cache-heavy serving patterns, while InfiniBand RDMA supports high-throughput cross-node scaling. The DataRobot/Nebius partnership provides a robust AI infrastructure:
- Managed kubernetes with GPU-aware scheduling simplifies STS installation and upgrades, pre-configured with NVIDIA operators.
- Dedicated GPU worker pools (H100, B200, etc.) isolate demanding STS services (LLM inference, vector databases) from generic CPU-only workloads.
- High-throughput networking and storage support large model artifacts, embeddings, and telemetry for continuous evaluation and logging.
- Security and tenancy is maintained: STS uses dedicated tenant boundaries, while Nebius IAM and network policies meet enterprise requirements.
- Built-in node health monitoring proactively identifies and addresses GPU/network issues for stable clusters and smarter maintenance.
2. Governed, monitored model inference deployment
The challenge with GenAI isn’t getting a model running; it’s getting it running with the same monitoring, governance, and security your organization expects. DataRobot’s NVIDIA NIM integration deploys NIM containers from NGC onto Nebius GPUs in four clicks:
- In Registry > Models, click Import from NVIDIA NGC and browse the NIM gallery.
- Select the model, review the NGC model card, and choose a performance profile.
- Review the GPU resource bundle automatically recommended based on the NIM’s requirements.
- Click Deploy, select the Serverless environment, and deploy the model.
Out-of-the-box observability and governance for deployed models
- Automated monitoring & risk assessment: Leverage the NeMo Evaluator integration for model faithfulness, groundness, and relevance scoring. Automatically scan for Bias, PII, and Prompt Injection risks.
- Real-time moderation & deep observability: DataRobot offers a platform for NIM moderation and monitoring. Deploy out-of-the-box guards for risks like PII, Prompt Injection, Toxicity, and Content Safety. OTel-compliant monitoring provides visibility into NIM operational health, quality, safety, and resource use.
- Enterprise governance & compliance: DataRobot provides the administrative layer for safe, organization-wide scaling. It automatically compiles monitoring and evaluation data into compliance documentation, mapping performance to regulatory standards for audits and reporting.
3. Agent deployment using the Workload API
An MCP tool server, a LangGraph agent, a FastAPI backend, composite systems built using combination of say LLMs and domain specific libraries like cuOpt, PhysicsNemo etc; these are containers, not models, and they need their own path to production. The Workload API gives you a governed endpoint with autoscaling, monitoring, and RBAC in a single API call.
curl -X POST "${DATAROBOT_API_ENDPOINT}/workloads/" \
-H "Authorization: Bearer ${DATAROBOT_API_TOKEN}" \
-H "Content-Type: application/json" \
-d '{
"name": "agent-service",
"importance": "HIGH",
"artifact": {
"name": "agent-service-v1",
"status": "locked",
"spec": {
"containerGroups": [{
"containers": [{
"imageUri": "your-registry/agent-service:latest",
"port": 8080,
"primary": true,
"entrypoint": ["python", "server.py"],
"resourceRequest": {"cpu": 1, "memory": 536870912},
"environmentVars": [
],
"readinessProbe": {"path": "/readyz", "port": 8080}
}]
}]
}
},
"runtime": {
"replicaCount": 2,
"autoscaling": {
"enabled": true,
"policies": [{
"scalingMetric": "inferenceQueueDepth",
"target": 70,
"minCount": 1,
"maxCount": 5
}]
}
}
}'
The agent is immediately accessible at /endpoints/workloads/{id}/ with monitoring, RBAC, audit trails, and autoscaling.
Out-of-the-box observability and governance for deployed agentic workloads
DataRobot drives the AI Factory by providing robust governance and observability for agentic workloads:
- Observability (OTel Standard): DataRobot standardizes on OpenTelemetry (OTel): logs, metrics, and traces—to ensure consistent, high-fidelity telemetry for all deployed entities. This telemetry seamlessly integrates with existing enterprise observability stacks, allowing users to monitor critical dimensions, including:
- Agent-specific metrics: Such as Agent Task Adherence and Agent Task Accuracy.
- Operational health and resource utilization.
- Tracing and Logging: OTel-compliant tracing interweaves container-level logs with execution spans to simplify root cause analysis within complex logic loops.
- Governance and Access Control: DataRobot enforces enterprise-wide authentication and authorization protocols across deployed agents using OAuth-based access control combined with Role-Based Access Control (RBAC).
4. Enterprise-ready agent building capabilities
A comprehensive toolkit for every builder with the DataRobot Agent Workforce Platform on Nebius
The DataRobot Agent Workforce Platform helps developers build agents faster by extending existing flows. Our builder kits support complex multi-agent workflows and single-purpose bots, accommodating various tools and environments.
Our kit includes native support includes:
- Open source frameworks: Native integration with LangChain, CrewAI, and LlamaIndex.
- NAT (Node Architecture Tooling): DataRobot’s framework for modular, node-based agent design.
- Advanced standards: Skills, MCP (Model Context Protocol) for data/tool interaction, and robust Prompt Management for versioning/optimization.
The Nebius advantage: DataRobot’s Agent Workforce Platform integrates with the Nebius Token Factory, allowing developers to consume models like Nemotron 3 (and any open source model) on a pay-per-token basis during the experimental phase. This enables rapid, low-cost iteration without heavy infrastructure provisioning. Once perfected, agents can seamlessly transition from the Token Factory to a dedicated deployment (e.g., NVIDIA NIM) for enterprise scale and low latency.
Getting Started: Building is simple using our Node Architecture Tooling (NAT). You define agent nodes as structured, testable steps in YAML.
First, connect your deployed LLM in the Nebius token factors to DataRobot
Add DataRobot deployment to you agentic starter application in the DataRobot CLI
functions:
planner:
_type: chat_completion
llm_name: datarobot_llm
system_prompt: |
You are a content planner. You create brief, structured outlines for blog articles.
You identify the most important points and cite relevant sources. Keep it simple and to the point -
this is just an outline for the writer.
Create a simple outline with:
1. 10-15 key points or facts (bullet points only, no paragraphs)
2. 2-3 relevant sources or references
3. A brief suggested structure (intro, 2-3 sections, conclusion)
Do NOT write paragraphs or detailed explanations. Just provide a focused list.
writer:
_type: chat_completion
llm_name: datarobot_llm
system_prompt: |
You are a content writer working with a planner colleague.
You write opinion pieces based on the planner's outline and context. You provide objective and
impartial insights backed by the planner's information. You acknowledge when your statements are
opinions versus objective facts.
1. Use the content plan to craft a compelling blog post.
2. Structure with an engaging introduction, insightful body, and summarizing conclusion.
3. Sections/Subtitles are properly named in an engaging manner.
4. CRITICAL: Keep the total output under 500 words. Each section should have 1-2 brief paragraphs.
Write in markdown format, ready for publication.
content_writer_pipeline:
_type: sequential_executor
tool_list: [planner, writer]
description: A tool that plans and writes content on the requested topic.
function_groups:
mcp_tools:
_type: datarobot_mcp_client
authentication:
datarobot_mcp_auth:
_type: datarobot_mcp_auth
llms:
datarobot_llm:
_type: datarobot-llm-component
workflow:
_type: tool_calling_agent
llm_name: datarobot_llm
tool_names:
- content_writer_pipeline
- mcp_tools
return_direct:
- content_writer_pipeline
system_prompt:
Choose and call a tool to answer the query.
Evaluation capabilities: The “how-to”
Building is only half the battle; knowing if it works is the other. Our evaluation framework moves beyond simple “thumbs up/down” and into data-driven validation.
To evaluate your agent, you can:
- Define a test suite: Upload a “golden dataset” of expected queries and ground-truth answers.
- Automated metrics: Run your agent against built-in evaluators for faithfulness, relevance, and toxicity.
- LLM-as-a-Judge: Use a “critic” model to score agent responses based on custom rubrics (e.g., “Did the agent follow the brand’s tone of voice?”).
- Side-by-side comparison: Run two versions of your agent (e.g., one using NAT and one using LangChain) against the same dataset to compare cost, latency, and accuracy in a single dashboard.
Enterprise hooks: Deployment-ready from day one
We automate the “enterprise tax” (security, logging, auth) that separates notebooks from production services by embedding build “hooks”:
- Observability: Automatic OTel-compliant tracing captures every step without boilerplate.
- Identity & auth: Built-in OAuth 2.0 and Service Accounts ensure agents use the user’s actual permissions when calling internal APIs (CRM, ERP), maintaining strict security.
- Production hand-off: Deployment packages the environment, components, and auth hooks into a secure, governed container, ensuring a consistent agent from dev to production. Complex agents are autoparsed into orchestrated containers for granular monitoring while deployed as a single pipeline entity.
Governed, scalable inference
The DataRobot and Nebius partnership delivers a validated, enterprise-ready deployment stack for agentic AI built on NVIDIA accelerated computing. For teams moving beyond experimentation, it provides a governed and scalable path to sustained production inference.
Nebius and DataRobot will be showcasing this solution at NVIDIA GTC 2026, taking place March 16-19 in San Jose, California.
Read the press release
Read the executive summary blog
Connect with DataRobot (booth #104) and Nebius (booth #713) at GTC 2026