What's the best AI model for controlling a fleet of different robots?

When controlling a heterogeneous fleet of different robots (e.g., combining wheeled AGVs, quadrupedal dogs, robotic arms, and humanoids), there is no single "AI model" that directly controls the physical actuators of every distinct machine out of the box.

Instead, the industry relies on a Hierarchical AI Architecture —pairing a high-level Multi-Robot Task Allocation (MRTA) / Fleet Orchestrator with low-level Vision-Language-Action (VLA) foundation models running on the individual nodes.

1. The Top-Level Fleet Orchestrator (The "Manager")

For coordinating high-level, cross-platform tasks (e.g., "Quadruped inspect sector B, then signal the mobile manipulator to pick up the dropped part" ), centralized multi-robot frameworks are used:

• RobotFleet / Open-Source LLM Frameworks: Emerging centralized multi-robot task planners use Large Language Models (LLMs) to ingest high-level human goals, decompose them into dependency graphs, and dynamically allocate tasks across a mixed fleet running containerized ROS 2 stacks.
• Amazon DeepFleet AI: The gold standard for massive proprietary heterogeneous fleets (coordinating AGVs, robotic sorting arms like Sparrow/Cardinal, and bipedal units). It uses deep reinforcement learning for centralized traffic routing and predictive task dispatch, though it is custom-built for Amazon's ecosystem.
• NVIDIA Omniverse & Isaac Platform: Rather than being a single model, NVIDIA’s simulation-first orchestration ecosystem acts as the central digital twin operating system. Using OpenUSD and Isaac Sim, it allows mixed fleets to share a unified spatial understanding, letting different robot "brains" reason, map, and synchronize within a shared digital twin before executing commands in reality.

2. The Individual Robot "Brains" (The "Workers")

At the single-robot level, universal physical AI models translate high-level text or visual commands from the orchestrator into motor/navigation actions tailored to each robot's specific physical form factor (its "embodiment"):

• NVIDIA GR00T (N1.5 / N1.6)Go to product viewer dialog for this item.: A leading foundational architecture for generalized humanoid and multi-embodiment reasoning. It uses a Vision-Language Model (VLM) backbone combined with state-relative action chunking to generalize skills across different bimanual and locomanipulation platforms.
• Figure AI π0 / π0.5: Designed for cross-embodiment co-training, enabling generalized real-world robotic manipulation that bridges high-level semantic instructions with low-level control.
• Open-Source VLM/VLA Stack (OpenVLA / Ψ0): Increasingly utilized by engineering teams to fine-tune open weights across mixed hardware configurations, decoupling the high-level vision-language understanding from the robot's specific kinematic constraints.

Recommended Approach for a Mixed Fleet

If you are designing or deploying a multi-vendor robot ecosystem, the most robust architecture combines:

If you'd like to narrow this down, tell me:

• What types of robots are in your fleet (e.g., mobile bases, arms, humanoids)?
• Is your environment indoor (structured/warehouse) or outdoor/unstructured?
• Do you need a centralized cloud orchestrator or an on-premise edge solution?

For controlling a fleet of different robots, the best choice is usually not a single AI model that directly drives every motor. The strongest architecture today is a robotics foundation model (often a Vision-Language-Action model, VLA) acting as a high-level “brain,” combined with robot-specific controllers underneath.

A practical ranking:

For a real fleet architecture, I would typically build:

                Fleet AI Supervisor
          (LLM/VLM/VLA reasoning layer)
                       |
        ---------------------------------
        |               |               |
    Robot A         Robot B          Robot C
  (arm)          (drone)        (mobile base)
        |               |               |
  Local policy     Local policy    Local policy
  + safety ctrl    + safety ctrl   + safety ctrl
        |
 Real-time motor controllers

The top model handles:

• "Move these robots to inspect the warehouse"
• "Have robot 3 pick damaged items"
• "Reassign tasks if robot 2 fails"
• "Understand camera feeds and human instructions"

The lower layers handle:

• milliseconds-level control loops
• collision avoidance
• balance
• force control
• emergency stops

A large language model by itself is generally too slow and unreliable for direct motor control; current robotics systems separate reasoning from fast control.

My recommendation by scenario

• Research lab / mixed robot fleet: NVIDIA Isaac stack + an open VLA (OpenVLA/GR00T-style) is probably the most flexible.
• Industrial fleet deployment: Use a robotics foundation model with your own safety layer and task planner.
• Startup building a “one brain, many bodies” robot platform: Evaluate Physical Intelligence-style cross-embodiment models or build around an open VLA.
• Autonomous warehouse/service robots: A hybrid of VLM planner + classical robotics (ROS 2, SLAM, MPC, safety controllers) is still the most robust approach.

The “best” model depends heavily on what your fleet contains. A fleet of robot arms, humanoids, drones, and AGVs would likely choose different stacks.

• milliseconds-level control loops
• collision avoidance
• balance
• force control
• emergency stops

A large language model by itself is generally too slow and unreliable for direct motor control; current robotics systems separate reasoning from fast control.

My recommendation by scenario

Controlling a heterogeneous fleet of different robots (e.g., mixing robotic arms, mobile AGVs/AMRs, quadrupeds, and humanoids) requires a hierarchical architecture rather than a single monolithic model.

The industry standard approach splits the problem into two layers: a High-Level Cognitive/Orchestration Foundation Model for multi-agent reasoning and task allocation, paired with Embodied Vision-Language-Action (VLA) models or hardware-specific policies running at the edge for low-level execution.

The top systems and frameworks used for heterogeneous robot fleet control include:

• Google DeepMind (RT-X / Gemini Robotics Architecture) : Utilizing cross-embodiment training via the Open X-Embodiment dataset, Google’s robotics framework allows a single family of models to transfer knowledge across completely different robot morphologies. Iterations focusing on whole-body intelligence and multi-robot collaboration make it a powerful choice for high-level semantic reasoning translated into diverse physical actions.
• NVIDIA Omniverse & Isaac / Multi-Agent Foundation Models : NVIDIA provides the premier simulation and orchestration stack. By combining large language models for task parsing with physics-based digital twins in NVIDIA Omniverse , mixed fleets (wheeled, legged, and aerial) can coordinate, share spatial data, and perform real-time path planning and collision avoidance.
• Skild AI : Focused heavily on robot-agnostic general intelligence, Skild acts as a foundational brain designed to scale across diverse hardware form factors without requiring individual, custom-coded control pipelines for every single machine type.
• Distributed Serving Architectures (e.g., Rosa / Ray-backed frameworks) : For actual deployment infrastructure in industrial settings, architectures like Rosa (Robotics Oriented Serving Architecture) use shared server-class GPU pools over a network to serve foundation models to a mixed robot fleet, optimizing factory-wide objectives rather than single-robot latency.

To narrow down the best specific framework or model setup for your project, tell me:

• What types of robots are in your fleet (e.g., mobile bases, arms, drones)?
• What is the primary environment (structured warehouse vs. unstructured outdoor/rescue)?
• Are you looking for cloud/server-based orchestration or edge-computed autonomy?

If you mean one AI “brain” coordinating a heterogeneous fleet—say wheeled robots, robot arms, drones, quadrupeds, and humanoids—the best answer today is not a single model directly driving every motor. The strongest architecture is a hierarchical system:

1. Fleet-level reasoning/planning: a strong multimodal LLM/VLM decides what needs to happen, allocates tasks, monitors failures, and replans.
2. Robot-specific VLA policies: models such as NVIDIA GR00T or Gemini Robotics translate those goals into actions appropriate to each robot.
3. Classical/local controllers: ROS 2, MPC, PID, SLAM, collision avoidance, safety interlocks, etc. handle the low-level real-time control.

This distinction matters because current VLAs are generally still optimized around individual robot embodiments, while recent multi-robot research specifically identifies task allocation, communication, and long-horizon replanning as a separate LLM-level problem.

My picks

GR00T is particularly compelling because its current architecture supports multiple embodiments and custom robot adaptation, including a NEW_EMBODIMENT mechanism for your own robot. NVIDIA also explicitly supports a server/client architecture where multiple robots can send observations to a centralized GPU inference server.

Google's Gemini Robotics On-Device 2 is also specifically designed for general-purpose manipulation across multiple robot types, with local inference being a major advantage where latency/connectivity matter.

If I were building the fleet

I'd probably do:

Fleet Manager LLM → understands mission / environment / robot capabilities → assigns jobs → maintains shared world state → replans when robots fail

↓

Robot abstraction layer

Robot A: mobile base + arm
Robot B: quadruped
Robot C: drone
Robot D: humanoid

↓

Per-embodiment VLA

GR00T / Gemini Robotics / specialized policy

↓

ROS 2 + safety controller

trajectory → collision checking → motor commands

For a large fleet, I'd also strongly consider centralized GPU inference rather than putting a giant model on every robot. NVIDIA's recent ROSA research is explicitly aimed at this problem: a shared GPU pool serving many robots, with scheduling based on fleet/factory objectives rather than simply minimizing one robot's inference latency.

The important caveat

If by "controlling" you mean coordinating 100+ genuinely different robots in real time, I would not choose an LLM and give it direct actuator control. The interesting problem is really multi-agent orchestration + robot foundation models + conventional control.

The field is moving toward exactly this architecture: recent work argues that robot foundation models need to become more multi-agent/alliance-aware, while separate research is exploring LLM-based hierarchical planning for heterogeneous robot teams.

So my current recommendation:

Best overall architecture: a top-tier reasoning model as the fleet commander + GR00T (or Gemini Robotics) as the robot-action layer + ROS 2/local controllers underneath. If you tell me what kinds of robots are in your fleet (e.g. drones + UGVs + arms + humanoids), fleet size, and whether you're using ROS 2, I can recommend a concrete architecture and model stack—including which model should run centrally versus on each robot.

If by “controlling a fleet of different robots” you mean one AI system that can coordinate heterogeneous robots—arms, mobile robots, drones, humanoids, etc.—I would not choose a conventional LLM as the low-level controller. The strongest architecture in 2026 is a robot foundation model / Vision-Language-Action (VLA) model, sitting underneath a fleet-level planner and above conventional real-time controllers.

My current picks

The reason I'd put GR00T at the top for your particular question is that heterogeneous embodiment is exactly the problem these systems are trying to solve. NVIDIA's ecosystem also gives you simulation, perception, training, deployment, and robot-specific adaptation rather than just a model. The 2026 landscape includes GR00T, Gemini Robotics, π0, Skild Brain and others as the major general-purpose robot foundation-model families.

Interestingly, X-VLA is explicitly designed around the heterogeneity problem: it uses embodiment-specific soft prompts so one backbone can accommodate different robot morphologies, sensors and action spaces. Its reported experiments span seven robotic platforms.

But I wouldn't actually let the model directly drive the fleet

For a serious fleet, I'd use something like:

                 Human / Mission
                       │
                       ▼
             ┌──────────────────┐
             │ Fleet AI / LLM   │
             │ Planning +       │
             │ task allocation  │
             └────────┬─────────┘
                      │
             ┌────────▼─────────┐
             │ Robot Foundation │
             │ Model (VLA)      │
             └────────┬─────────┘
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
       Robot A     Robot B     Robot C
       ┌──────┐    ┌──────┐    ┌──────┐
       │local │    │local │    │local │
       │policy│    │policy│    │policy│
       └──┬───┘    └──┬───┘    └──┬───┘
          ▼           ▼           ▼
       real-time controllers / safety layer

The important distinction is fleet intelligence vs. motor control. The foundation model decides things like “send the mobile robot to retrieve the part, then have the arm pick it up and place it on the conveyor.” A deterministic/local controller handles the 200–1000 Hz safety and motion-control loop. Current industrial robotics research is converging toward this kind of layered architecture.

One especially interesting development

There are now models explicitly targeting cross-embodiment action spaces. For example, the August 2026 G0.5 paper describes a shared action tokenizer for heterogeneous robots, while τ₀-VLA uses a hierarchical policy in which high-level subtasks can be generated and searched before a lower-level policy executes them across multiple robot embodiments.

That is much closer to what I'd want for a fleet brain than simply putting GPT/Gemini in front of each robot.

Bottom line:

• Building a real heterogeneous fleet today → NVIDIA GR00T + Isaac ecosystem
• Want strongest proprietary reasoning/robotics integration → Gemini Robotics
• Want manipulation-focused research → π0
• Want a potentially very strong “one brain, many bodies” architecture → Skild AI / X-VLA
• Want to build the fleet intelligence yourself → use an LLM/VLM for mission planning + VLA for embodiment/action + conventional controllers for safety

If you tell me what kinds of robots are in the fleet (e.g. Unitree humanoids + quadrupeds + UR arms + AMRs + drones), I can narrow this down to a specific architecture and model stack.

There is no single "best" AI model that directly handles low-level control for a mixed (heterogeneous) fleet of entirely different robots . Instead, the industry relies on a hierarchical architecture : a high-level multi-agent foundation model or LLM planner handles task allocation, intent parsing, and traffic orchestration, while individual edge models (like Vision-Language-Action models) handle local embodiment.

The top-performing frameworks and models driving heterogeneous fleet control break down by their layer in the stack:

• Top-Level Orchestration & Task Planning
  • Open-RMF (Open Robot Management Framework): Maintained by Open Robotics, this is the gold-standard open framework for managing mixed fleets (e.g., integrating mobile robots, automated guided vehicles, and robotic arms from different vendors) under a shared architecture.
  • RobotFleet / LLM-Based Frameworks: Recent open architectures use Large Language Models (like GPT-4o or Claude 3.5 Sonnet) as the high-level semantic planner. They take a natural language goal (e.g., "Inspect the north wing and clean any spills" ), break it down into a dependency graph of subtasks, and dispatch them to the correct robot type.
  • Amazon DeepFleet: A pioneering multi-agent foundation model architecture designed specifically for large-scale mobile robot fleets. It utilizes robot-centric (RC) and graph-floor (GF) transformers to predict spatial interactions, avoid congestion, and optimize paths across diverse robot types.
• Simulation, Digital Twins & Fleet Optimization
  • NVIDIA Isaac / Omniverse Platform: The premier full-stack ecosystem for simulating and deploying AI-powered multi-robot environments. It allows developers to test heterogeneous robot morphologies (wheeled, legged, aerial) in a shared digital twin before pushing policies to the physical fleet.
  • Vendor-Specific AI Orchestrators (ABB RobotStudio, FANUC, GreyMatter): If your fleet consists heavily of industrial or warehouse units, enterprise platforms use deep reinforcement learning to dynamically reassign tasks, manage charging states, and prevent gridlock across hundreds of units.
• Edge Control & Embodied AI (The Robot Brains)
  • Vision-Language-Action (VLA) Models (e.g., OpenVLA, Google RT-2, Physical Intelligence's π₀): These models sit on the individual robots. They translate high-level visual inputs and language instructions into physical motor control actions, allowing different robot types to comprehend novel, unstructured tasks on the fly.

To help narrow down the ideal approach for your setup, tell me:

• What types of robots are in your fleet (e.g., mobile AMRs, drones, robotic arms, humanoids)?
• What is the primary environment (e.g., a structured warehouse, outdoor terrain, unstructured factory floor)?

I can recommend a specific integration blueprint or software stack.

Controlling a heterogeneous fleet (different types of robots—like AMRs, robotic arms, quadrupeds, and humanoids) requires a two-tier AI architecture . No single neural network safely handles low-level motor control for a biped while simultaneously managing global path traffic planning for a warehouse forklift.

Instead, the industry relies on a combination of High-Level Task/Fleet Orchestration Models and Low-Level Cross-Embodiment Foundation Models.

Tier 1: High-Level Fleet Planning & Task Orchestration (The "Brain")

For breaking down a human command ("Restock Zone B, prioritizing fragile items"), assigning tasks based on battery/location, and preventing deadlocks across different machine types, these are the top frameworks:

• RobotFleet / Open-Source Frameworks: Emerging open-source multi-agent frameworks (such as RobotFleet on arXiv ) use an LLM cognitive layer to turn high-level goals into dependency subtask graphs, paired with a centralized scheduler communicating via containerized ROS 2 worker nodes. Ideal if you want a modular, vendor-agnostic stack.
• DeepFleet (Amazon): A multi-agent foundation model architecture specifically trained on massive real-world fleet movement and congestion data. It features distinct variants (like Robot-Centric and Graph-Floor transformers) optimized for asynchronous multi-robot spatial coordination.
• Enterprise RobOps Platforms (e.g., InOrbit): While not a raw LLM, InOrbit provides the production-grade AI orchestration backbone used to tie diverse vendor hardware together, handling real-time telemetry, incident detection, and adaptive multi-robot coordination.

Tier 2: Cross-Embodiment & Navigation Foundation Models (The "Body")

To let a single or generalized AI model understand movement and perception across completely different physical bodies (wheeled vs. legged vs. drones):

• Navigation Foundation Models (NavFoM): Systems like Galbot's NavFoM provide cross-embodiment navigation, translating natural language or central commands into safe local path planning regardless of whether the chassis is a quadruped or a wheeled robot.
• Google's RT-X / AutoRT Family: Built on top of Vision-Language-Action (VLA) principles, the RT-X ecosystem allows data and skills to transfer across entirely different robot embodiments. AutoRT specifically adds the capability for multi-agent coordination and contextual scene understanding in dynamic environments.
• NVIDIA Isaac / GR00T Frameworks: Utilized heavily for physical AI development, providing dual-system architectures that separate slow semantic reasoning from fast, real-time reactive control policies across diverse hardware.

The Practical Verdict

The "best" approach isn't a standalone off-the-shelf LLM, but a hybrid stack:

1. Use an LLM/Graph-based central scheduler (like RobotFleet or custom ROS 3 / Open-RMF architecture) for fleet-wide task allocation and traffic management.
2. Standardize communication via VDA5050 or ROS 2 so every robot speaks the same protocol regardless of manufacturer.
3. Delegate low-level execution to localized cross-embodiment VLA/Navigation models running on the edge of each distinct robot.

If you want to narrow this down, tell me:

• What specific types of robots are in your fleet (e.g., AMRs, robotic arms, drones)?
• What is the primary environment they operate in (warehouse, outdoor, factory floor)?

I can give you a more tailored architecture recommendation.

If you mean one AI “brain” that can coordinate a heterogeneous fleet—robot arms, AMRs, quadrupeds, humanoids, drones, etc.—I would not put a single LLM directly in the motor-control loop. The best architecture in 2026 is a hierarchical system:

My top pick: NVIDIA Isaac + GR00T, with a strong reasoning model above it.

• Fleet/orchestration layer: ROS 2 + your own fleet scheduler/task planner.
• Reasoning layer: a frontier multimodal model (e.g. Gemini/Claude-class) that turns goals into robot tasks, reasons about failures, and coordinates multiple robots.
• Robot policy layer: NVIDIA Isaac GR00T for robots that it supports/adapts to. GR00T N1.7 is a cross-embodiment vision-language-action model and can be fine-tuned for specific hardware/tasks.
• Low-level control: conventional controllers, motion planners, SLAM, safety systems, etc.—not an LLM.

NVIDIA is particularly compelling because Isaac is an entire stack rather than just a model: simulation, robot learning, perception, manipulation, ROS 2 integration, deployment, and distributed workflow orchestration. It explicitly supports AMRs, arms, manipulators and humanoids.

What I'd choose by use case

One important distinction: GR00T isn't really a fleet-management model. It's primarily a robot foundation/VLA model that maps multimodal inputs and robot state to actions. developer.nvidia.com For a fleet, you want another layer deciding which robot should do what, in what order, and how to recover when one fails.

Anthropic has also demonstrated Claude controlling very different robot bodies, including a quadruped, humanoid, arm, and real Unitree Go2, which is interesting evidence that frontier reasoning models can serve as a high-level robotics interface. But their own experiments reinforce the idea of using the language model at an appropriate abstraction level rather than asking it to directly produce raw motor commands.

If you're actually building this, tell me what kinds of robots are in the fleet (e.g. ROS 2 wheeled robots + robot arms + drones + humanoids) and whether you need warehouse/industrial reliability or research flexibility. I can then recommend a concrete architecture—including the model, hardware, ROS 2 components, fleet scheduler, simulation stack, and how the robots communicate.

There is no single off-the-shelf "best" AI model that directly controls a mixed fleet of different robots from the metal up. Instead, the industry has converged on a hierarchical, two-layer architecture : a high-level Foundation/Reasoning Model for task decomposition and orchestration, coupled with localized Embodied/Control Policies or standard middleware (like ROS 2) running on each unique machine.

Managing a heterogeneous fleet (e.g., robotic arms, autonomous mobile robots (AMRs), and quadrupeds from different vendors) requires dividing the problem into cognitive orchestration and physical execution.

Phase 1: The High-Level Orchestrator (The "Brain")

At the fleet level, the AI model must translate human intent or high-level goals into a dynamic schedule of subtasks, route optimization, and conflict resolution across different machine types.

• Open/Research Frameworks: RobotFleet (an open-source multi-agent framework) uses Large Language Models (LLMs) to ingest a broad operational goal ("restock aisle 4"), build a dependency graph, and split tasks among heterogeneous, containerized robot workers.
• Enterprise/Proprietary Systems: Cutting-edge scaled implementations like Amazon's DeepFleet use multi-agent generative AI foundation models (built on architectures like graph-floor and robot-centric decision transformers) to coordinate massive, diverse robot inventories by treating the floor like an intelligent traffic grid.
• Vendor-Agnostic Platforms: Commercial industrial middleware and orchestration layers like GreyOrange GreyMatter or InOrbit provide the robust operational control planes required to bridge different vendor APIs.

Phase 2: The Cross-Embodiment Execution Layer (The "Body")

At the individual robot level, a model must handle physical actuation, navigation, and manipulation. Because a policy trained for a wheeled AMR will fail on a legged quadruped or a multi-axis arm, researchers use Omni-Body / Cross-Embodiment Models.

• Google DeepMind’s Cross-Embodiment Policies & π0 (Physical Intelligence): These Vision-Language-Action (VLA) and Large Behavior Models (LBMs) are trained on massive multi-robot datasets (such as the Open X-Embodiment dataset). They learn embodiment-agnostic representations, meaning a single core model architecture can understand physical tasks and translate them across varying joint configurations and sensor layouts with minimal fine-tuning.
• Boston Dynamics Large Behavior Models (LBMs): For high-dexterity or dynamic terrain traversal (like handling mixed manipulation with Spot or Atlas), LBMs using action-chunking predict whole-body physical responses from human demonstrations.

The Recommended Blueprint

If you are deploying an AI-driven heterogeneous fleet today, the optimal strategy is a hybrid stack:

1. Standardization: Adopt interoperability layers like the VDA5050 communication standard so that different hardware manufacturers speak a common telemetry language.
2. The Central Planner: Use a robust reasoning model or multi-agent orchestration layer (such as an LLM-backed task scheduler combined with mixed-integer linear programming) to allocate workloads based on real-time battery, location, and capability.
3. Edge Autonomy: Leave low-level reactive safety and obstacle avoidance to the individual robot's onboard ROS 2 / local navigation stack.

To help narrow down the best architecture, could you share:

• What types of robots are in the fleet (e.g., AMRs, robotic arms, drones)?
• What is the primary environment they operate in (e.g., a structured warehouse vs. an unstructured outdoor site)?

If you mean one AI “brain” that can coordinate a heterogeneous fleet—say wheeled AMRs, robot arms, drones, and humanoids—I would not use one model to directly control every motor. The strongest architecture today is a hierarchical multi-model stack.

My pick: Gemini Robotics + an orchestration layer

As of August 2026, Google DeepMind’s Gemini Robotics family is probably the strongest starting point for heterogeneous robot control. Gemini Robotics 1.5 is explicitly a vision-language-action (VLA) model designed to turn perception and instructions into robot actions, and DeepMind reports cross-embodiment learning, meaning skills can transfer across robots with different sizes and shapes.

For fleet-level control, I'd pair it with Gemini Robotics-ER 1.6 as the high-level reasoning/planning layer. It is designed for spatial reasoning, task planning, progress/success detection, and tool orchestration—exactly the kinds of things a fleet supervisor needs.

A practical architecture would look like:

                  Fleet Mission / Human Command
                             │
                             ▼
                 ┌─────────────────────────┐
                 │ Gemini Robotics-ER      │
                 │ Fleet reasoning/planning│
                 └────────────┬────────────┘
                              │
                     task allocation
                              │
             ┌────────────────┼────────────────┐
             ▼                ▼                ▼
          Robot A          Robot B          Robot C
         wheeled AMR       robot arm          drone
             │                │                │
        local policy      local policy      local policy
             │                │                │
        ROS 2 / Nav2       ROS 2 / MoveIt    PX4/etc.
             │                │                │
          motors           actuators         flight ctrl

The key idea is that the frontier model decides what should happen; deterministic robotics software decides how to safely make it happen.

The other serious contender: NVIDIA GR00T

If you want something more open/customizable and are willing to build around NVIDIA's ecosystem, I'd look very seriously at NVIDIA Isaac GR00T. GR00T is a foundation VLA model with a two-system architecture: one part handles reasoning/perception while another generates continuous robot actions. NVIDIA specifically designed it for generalization across robot embodiments.

Its biggest advantage is control over the stack: you can train/customize the model and use NVIDIA's simulation/data-generation ecosystem. For a company building its own fleet-learning platform, that can be more valuable than simply having access to the strongest closed model.

What I'd choose

One particularly important distinction: a fleet controller and a robot controller are different problems. Gemini Robotics can be the intelligent layer, but I would not let a frontier model directly issue arbitrary wheel velocities, joint torques, or flight commands. Put a constrained policy/controller underneath it with collision avoidance, geofencing, watchdogs, emergency stops, and formal operating limits.

If you're actually designing a fleet architecture, tell me what kinds of robots you have (e.g. AMRs + arms + drones + humanoids) and whether you're looking for commercial deployment or research. I can then recommend a concrete stack—including the model, ROS 2 architecture, fleet scheduler, simulation environment, GPUs/edge hardware, and how the robots communicate.