Your GPUs Are Everywhere. Your Robot-Learning Loop Shouldn't Be.
Robotics compute is spreading across clouds and clusters. Learn how one portable pipeline layer can keep the robot-learning loop reproducible.
Azure ML bundles pipelines, endpoints, registries, and monitoring into a single Azure-native suite. ZenML provides similar lifecycle controls while keeping your orchestration portable across AWS, GCP, Azure, and on-prem. If you're evaluating Azure ML for enterprise MLOps but want an exit strategy or a multi-cloud operating model, ZenML is the open-source alternative designed for that reality.
“ZenML has proven to be a critical asset in our machine learning toolbox, and we are excited to continue leveraging its capabilities to drive ADEO's machine learning initiatives to new heights”
François Serra
ML Engineer / ML Ops / ML Solution architect at ADEO Services
Feature-by-feature comparison
ZenML Azure ML | Workflow Orchestration | Purpose-built ML pipeline orchestration with pluggable backends — Airflow, Kubeflow, Kubernetes, and more | First-class DAG pipelines built from versioned components with UI, CLI, and SDK authoring plus built-in scheduling within Azure |
| Integration Flexibility | Composable stack with 50+ MLOps integrations — swap orchestrators, trackers, and deployers without code changes | Integrates well with Azure-native services and supports MLflow, but not built as a neutral integration hub for non-Azure tools |
| Vendor Lock-In | Open-source Python pipelines run anywhere — switch clouds, orchestrators, or tools without rewriting code | Fundamentally an Azure service — Arc-enabled K8s extends compute reach but governance and asset control remain tied to Azure workspaces |
| Setup Complexity | pip install zenml — start building pipelines in minutes with zero infrastructure, scale when ready | Initial setup requires workspace provisioning, IAM/RBAC, networking, and dependent Azure services like Storage, ACR, and Key Vault |
| Learning Curve | Python-native API with decorators — familiar to any ML engineer or data scientist who writes Python | Broad concept set (assets, resources, components, jobs, endpoints, registries) plus v1/v2 ecosystem fragmentation slows time-to-productivity |
| Scalability | Delegates compute to scalable backends — Kubernetes, Spark, cloud ML services — for unlimited horizontal scaling | Enterprise-scale managed training and inference on Azure compute, plus hybrid Kubernetes compute targets for large regulated deployments |
| Cost Model | Open-source core is free — pay only for your own infrastructure, with optional managed cloud for enterprise features | No separate platform fee, but total cost includes compute plus multiple Azure services (Storage, ACR, Key Vault, monitoring) that can be hard to predict |
| Collaboration | Code-native collaboration through Git, CI/CD, and code review — ZenML Pro adds RBAC, workspaces, and team dashboards | Workspaces, registries, and Azure RBAC make collaboration first-class — assets can be centrally managed and replicated across regions |
| ML Frameworks | Use any Python ML framework — TensorFlow, PyTorch, scikit-learn, XGBoost, LightGBM — with native materializers and tracking | Supports broad ML/DL workflows including no-code AutoML options and arbitrary training routines packaged as components or jobs |
| Monitoring | Integrates Evidently, WhyLogs, and other monitoring tools as stack components for automated drift detection and alerting | Deep Azure Monitor integration for endpoint metrics and logs, plus model monitoring with data drift signals and alerting via Event Grid |
| Governance | ZenML Pro provides RBAC, SSO, workspaces, and audit trails — self-hosted option keeps all data in your own infrastructure | Inherits Azure's enterprise governance model with RBAC, managed identities, registries with fine-grained permissions, and centralized asset management |
| Experiment Tracking | Native metadata tracking plus seamless integration with MLflow, Weights & Biases, Neptune, and Comet for rich experiment comparison | MLflow-compatible workspaces with automatic job metadata tracking — Azure ML recommends MLflow for metrics and params logging |
| Reproducibility | Automatic artifact versioning, code-to-Git linking, and containerized execution guarantee reproducible pipeline runs | Jobs automatically track code, environment, and inputs/outputs — versioned components and registries enable durable asset reuse across workspaces |
| Auto-Retraining | Schedule pipelines via any orchestrator or use ZenML Pro event triggers for drift-based automated retraining workflows | Supports scheduling pipeline jobs for routine retraining via UI, CLI, and SDK — though v2 schedules do not support event-based triggers |
Code comparison
ZenML from zenml import pipeline, step, Model
from zenml.integrations.mlflow.steps import (
mlflow_model_deployer_step,
)
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import numpy as np
@step
def ingest_data() -> pd.DataFrame:
return pd.read_csv("data/dataset.csv")
@step
def train_model(df: pd.DataFrame) -> RandomForestRegressor:
X, y = df.drop("target", axis=1), df["target"]
model = RandomForestRegressor(n_estimators=100)
model.fit(X, y)
return model
@step
def evaluate(model: RandomForestRegressor, df: pd.DataFrame) -> float:
X, y = df.drop("target", axis=1), df["target"]
preds = model.predict(X)
return float(np.sqrt(mean_squared_error(y, preds)))
@step
def check_drift(df: pd.DataFrame) -> bool:
# Plug in Evidently, Great Expectations, etc.
return detect_drift(df)
@pipeline(model=Model(name="my_model"))
def ml_pipeline():
df = ingest_data()
model = train_model(df)
rmse = evaluate(model, df)
drift = check_drift(df)
# Runs on any orchestrator, logs to MLflow,
# tracks artifacts, and triggers retraining — all
# in one portable, version-controlled pipeline
ml_pipeline()from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient, Input, dsl, load_component
credential = DefaultAzureCredential()
ml_client = MLClient(
credential=credential,
subscription_id=SUBSCRIPTION,
resource_group_name=RESOURCE_GROUP,
workspace_name=WORKSPACE,
)
credit_data = ml_client.data.get(name="credit-card", version="1")
prep = load_component(source="./components/data_prep.yml")
train = load_component(source="./components/train.yml")
@dsl.pipeline(compute="serverless", description="Prep + train")
def training_pipeline(data_input, test_ratio: float, model_name: str):
prep_job = prep(data=data_input, test_train_ratio=test_ratio)
train_job = train(
train_data=prep_job.outputs.train_data,
test_data=prep_job.outputs.test_data,
registered_model_name=model_name,
)
return {"model": train_job.outputs.model_output}
pipeline_job = training_pipeline(
data_input=Input(type="uri_file", path=credit_data.path),
test_ratio=0.25,
model_name="credit_defaults_model",
)
submitted = ml_client.jobs.create_or_update(
pipeline_job, experiment_name="credit-defaults"
)
ml_client.jobs.stream(submitted.name)
# Requires Azure subscription, workspace, IAM config.
# Pipelines tied to Azure ML workspace control plane.
# v1 SDK deprecated — must use v2 (azure-ai-ml).
ZenML is fully open-source and vendor-neutral, letting you avoid the significant licensing costs and platform lock-in of proprietary enterprise platforms. Your pipelines remain portable across any infrastructure, from local development to multi-cloud production.
ZenML offers a pip-installable, Python-first approach that lets you start locally and scale later. No enterprise deployment, platform operators, or Kubernetes clusters required to begin — build production-grade ML pipelines in minutes, not weeks.
ZenML's composable stack lets you choose your own orchestrator, experiment tracker, artifact store, and deployer. Swap components freely without re-platforming — your pipelines adapt to your toolchain, not the other way around.
Expand Your Knowledge
Robotics compute is spreading across clouds and clusters. Learn how one portable pipeline layer can keep the robot-learning loop reproducible.
Claude Agent SDK runs the agent loop. Kitaru adds the durable runtime around a completed invocation — checkpointed results, artifacts, replay boundaries, and waits.
LangGraph keeps graph state, threads, and interrupts. Kitaru adds the durable workflow around the graph call — replay boundaries, durable waits, and inspectable runs.
