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:

1. An enterprise-grade, scalable, reliable, and cost-effective runtime for models and agents, featuring out-of-the-box governance and monitoring.
2. 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:

1. In Registry > Models, click Import from NVIDIA NGC and browse the NIM gallery.
2. Select the model, review the NGC model card, and choose a performance profile.
3. Review the GPU resource bundle automatically recommended based on the NIM’s requirements.
4. 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:

1. Define a test suite: Upload a “golden dataset” of expected queries and ground-truth answers.
2. Automated metrics: Run your agent against built-in evaluators for faithfulness, relevance, and toxicity.
3. 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?”).
4. 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

The post DataRobot + Nebius: An enterprise-ready AI Factory optimized for agents appeared first on DataRobot.

Researchers have built a drone that runs on hydrogen, to replace battery-powered drones that are too heavy and have too short a range. This technology could help fix power outages faster and replace dangerous helicopter missions with the new drones.

Humans often use one hand to grasp the branch for better accessibility, while the other hand is used to perform primary tasks like (a) branch pruning and (b) hand pollination of the flower. (c) An overview of the approach used by Madhav and colleagues, where one robot manipulates the branch to move the flower to the field of view of another robot by planning a force-aware path. Figure from Force Aware Branch Manipulation To Assist Agricultural Tasks.

In their paper Force Aware Branch Manipulation To Assist Agricultural Tasks, which was presented at IROS 2025, Madhav Rijal, Rashik Shrestha, Trevor Smith, and Yu Gu proposed a methodology to safely manipulate branches to aid various agricultural tasks. We interviewed Madhav to find out more.

Could you give us an overview of the problem you were addressing in the paper?

Madhav Rijal (MR): Our work is motivated by StickBug [1], a multi-armed robotic system for precision pollination in greenhouse environments. One of the main challenges StickBug faces is that many flowers are partially or fully hidden within the plant canopy, making them difficult to detect and reach directly for pollination. This challenge also arises in other agricultural tasks, such as fruit harvesting, where target fruits may be occluded by surrounding branches and foliage.

To address this, we study how one robot arm can safely manipulate branches so that these occluded flowers can be brought into the field of view or reachable workspace of another robot arm. This is a challenging manipulation problem because plant branches are deformable, fragile, and vary significantly from one branch to another. In addition, unlike pick-and-place tasks, where objects move freely in space, branches remain attached to the plant, which imposes additional motion constraints during manipulation. If the robot moves a branch without accounting for these constraints and safety limits, it can apply excessive force and damage the branch.

So, the core problem we addressed in this paper is: how can a robot safely manipulate branches to reveal hidden flowers while remaining aware of interaction forces and minimizing damage?

How did your approach go about tackling the problem?

MR: Our approach [2] combines motion planning that accounts for branch constraints with real-time force feedback.

First, we generate a feasible manipulation path using an RRT* (rapidly exploring random tree) algorithm-based planner in the workspace. The planner respects the geometric constraints of the branch and the task requirements. We model branches as deformable linear objects and use a geometric heuristic to identify configurations that are safer to manipulate.

Then, during execution, we monitor the interaction force using a force sensor mounted on the manipulator. If the measured force exceeds a predefined safe threshold, the system does not continue along the same path. Instead, it re-plans the motion online and searches for an alternative path or goal configuration that can reduce branch stress while still achieving the task.

So, the key idea is that the robot does not plan only for reachability. It also adapts its motion based on the physical response of the branch during manipulation.

Madhav with the multi-armed pollination robot, StickBug.

What are the main contributions of your work?

MR: The main contributions of our work are:

1. A geometric heuristic model for branch manipulation that does not require branch-specific parameter tuning or physical probing.
2. A motion planning strategy for branch manipulation that respects both workspace and branch constraints, using the geometric heuristic to guide RRT* and incorporating online replanning based on force feedback.
3. An experimental demonstration showing that force feedback-based motion planning can protect branches from excessive force during manipulation.
4. Generalization across different branch types, since the method relies primarily on branch geometry and can adapt online to compensate for model inaccuracies.

Could you talk about the experiments that you carried out to test the approach?

MR: We evaluated the proposed method through a set of branch manipulation experiments using five different starting poses, all targeting a common goal region. Each configuration was tested 10 times, resulting in a total of 50 trials. A trial was considered successful if the robot brought the grasp point to within 5 cm of the goal point. For all trials, the planning time limit was set to 400 seconds, and the allowable interaction force range was −40 N to 40 N. Across the 50 trials, 39 were successful and 11 failed, corresponding to a success rate of about 78%. The average number of replanning attempts across all scenarios was 20.

In terms of force reduction, the results show a clear progression in safety. Constraint-aware planning reduced the manipulation force from above 100 N to below 60 N. Building on this, online force-aware replanning further reduced the force from about 60 N to below the desired 40 N threshold. This indicates that safety awareness through geometric heuristics, which model branches as deformable linear objects, together with force-aware online replanning, can effectively lower interaction forces during manipulation.

Overall, the experiments demonstrate that the proposed framework enables safer branch manipulation while maintaining task feasibility. By combining branch-constraint-aware planning with real-time force feedback, the robot can adapt its motion to reduce excessive force and minimize the risk of branch damage. These findings highlight the value of force-aware planning for practical robotic manipulation in agricultural environments.

Do you have plans to further extend this work?

MR: Yes, there are several directions for extending this work.

One current limitation is the need to define a safe force threshold in advance. In practice, different types of branches require different force limits for safe manipulation. A key direction for future work is to learn or estimate safe force thresholds automatically from branch geometry or visual cues.

Another extension is to improve grasp-point selection. Instead of only replanning after grasping, the system could also reason about the most suitable grasp point beforehand so that the required manipulation force is reduced from the start.

We are also interested in designing a compliant gripper with integrated force sensing that is better suited for manipulating delicate branches. In the longer term, we plan to integrate this method into a multi-arm agricultural robot, where one arm manipulates the branch and another performs pollination, pruning, or harvesting.

Overall, this work advances the development of agricultural robots that can actively manipulate branches to support tasks such as harvesting, pruning, and pollination. By exposing fruits, cut points, and hidden flowers within the canopy, this capability can help overcome key barriers to the broader adoption of robot-assisted agricultural technologies.

References

[1] Smith, Trevor, Madhav Rijal, Christopher Tatsch, R. Michael Butts, Jared Beard, R. Tyler Cook, Andy Chu, Jason Gross, and Yu Gu. Design of Stickbug: a six-armed precision pollination robot. In 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 69-75. IEEE, 2024.
[2] Rijal, Madhav, Rashik Shrestha, Trevor Smith, and Yu Gu, Force Aware Branch Manipulation To Assist Agricultural Tasks. In 2025 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 1217-1222. IEEE, 2025.

About Madhav

Madhav Rijal is a Ph.D. candidate in Mechanical Engineering at West Virginia University working in agricultural robotics. His research combines motion planning, optimization, multi-agent collaboration and distributed decision making to develop robotic systems for precision pollination and other plant-interaction tasks. His current work focuses on branch manipulation and safe robot operation in agricultural environments.