Choosing a sandbox runtime for long-lived coding agents
How we evaluated sandbox providers for coding agents, what we chose for now, and the trade-offs behind that decision.
Run the same workloads on any cloud to gain strategic flexibility
- ZenML does not tie your work to one cloud.
- Define infrastructure as stack components independent of your code.
- Run any code on any stack with minimum fuss.
50+ integrations with the most popular cloud and open-source tools
- From experiment trackers like MLflow and Weights & Biases to model deployers like Seldon and BentoML, ZenML has integrations for tools across the lifecycle.
- Flexibly run workflows across all clouds or orchestration tools such as Airflow or Kubeflow.
- AWS, GCP, and Azure integrations all supported out of the box.
Avoid getting locked in to a vendor
- Avoid tangling up code with tooling libraries that make it hard to transition.
- Easily set up multiple stacks for different teams with different requirements.
- Switch between tools and platforms seamlessly.
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
Explore in Detail What Makes ZenML Unique
| Feature | ZenML | Azure ML |
|---|---|---|
| Workflow Orchestration | Yes Purpose-built ML pipeline orchestration with pluggable backends — Airflow, Kubeflow, Kubernetes, and more |
Yes First-class DAG pipelines built from versioned components with UI, CLI, and SDK authoring plus built-in scheduling within Azure |
| Integration Flexibility | Yes Composable stack with 50+ MLOps integrations — swap orchestrators, trackers, and deployers without code changes |
Not supported Integrates well with Azure-native services and supports MLflow, but not built as a neutral integration hub for non-Azure tools |
| Vendor Lock-In | Yes Open-source Python pipelines run anywhere — switch clouds, orchestrators, or tools without rewriting code |
Not supported Fundamentally an Azure service — Arc-enabled K8s extends compute reach but governance and asset control remain tied to Azure workspaces |
| Setup Complexity | Yes pip install zenml — start building pipelines in minutes with zero infrastructure, scale when ready |
Not supported Initial setup requires workspace provisioning, IAM/RBAC, networking, and dependent Azure services like Storage, ACR, and Key Vault |
| Learning Curve | Yes Python-native API with decorators — familiar to any ML engineer or data scientist who writes Python |
Not supported Broad concept set (assets, resources, components, jobs, endpoints, registries) plus v1/v2 ecosystem fragmentation slows time-to-productivity |
| Scalability | Yes Delegates compute to scalable backends — Kubernetes, Spark, cloud ML services — for unlimited horizontal scaling |
Yes Enterprise-scale managed training and inference on Azure compute, plus hybrid Kubernetes compute targets for large regulated deployments |
| Cost Model | Yes Open-source core is free — pay only for your own infrastructure, with optional managed cloud for enterprise features |
Not supported 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 | Yes Code-native collaboration through Git, CI/CD, and code review — ZenML Pro adds RBAC, workspaces, and team dashboards |
Yes Workspaces, registries, and Azure RBAC make collaboration first-class — assets can be centrally managed and replicated across regions |
| ML Frameworks | Yes Use any Python ML framework — TensorFlow, PyTorch, scikit-learn, XGBoost, LightGBM — with native materializers and tracking |
Yes Supports broad ML/DL workflows including no-code AutoML options and arbitrary training routines packaged as components or jobs |
| Monitoring | Yes Integrates Evidently, WhyLogs, and other monitoring tools as stack components for automated drift detection and alerting |
Yes Deep Azure Monitor integration for endpoint metrics and logs, plus model monitoring with data drift signals and alerting via Event Grid |
| Governance | Yes ZenML Pro provides RBAC, SSO, workspaces, and audit trails — self-hosted option keeps all data in your own infrastructure |
Yes Inherits Azure's enterprise governance model with RBAC, managed identities, registries with fine-grained permissions, and centralized asset management |
| Experiment Tracking | Yes Native metadata tracking plus seamless integration with MLflow, Weights & Biases, Neptune, and Comet for rich experiment comparison |
Yes MLflow-compatible workspaces with automatic job metadata tracking — Azure ML recommends MLflow for metrics and params logging |
| Reproducibility | Yes Automatic artifact versioning, code-to-Git linking, and containerized execution guarantee reproducible pipeline runs |
Yes Jobs automatically track code, environment, and inputs/outputs — versioned components and registries enable durable asset reuse across workspaces |
| Auto-Retraining | Yes Schedule pipelines via any orchestrator or use ZenML Pro event triggers for drift-based automated retraining workflows |
Yes Supports scheduling pipeline jobs for routine retraining via UI, CLI, and SDK — though v2 schedules do not support event-based triggers |
Code comparison
ZenML and Azure ML side by side
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).01.
Open-Source and Vendor-Neutral
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.
02.
Lightweight, Code-First Development
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.
03.
Composable Stack Architecture
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.
Outperform E2E Platforms: Book Your Free ZenML Strategy Talk
E2E Platform Showdown
Explore the Advantages of ZenML Over Other E2E Platform Tools
ZenML vs Alteryx
Alteryx alternative for ML pipelines: open-source, code-first MLOps with vendor-neutral portability. Build production ML workflows that run anywhere
ZenML vs AWS Sagemaker
Vendor-neutral ML orchestration. Build, train, and deploy models across environments with flexible workflows and no cloud lock-in.
ZenML vs ClearML
ClearML alternative: Flexible MLOps framework with extensive integrations. Accelerate ML development using adaptable architecture and reduced lock-in, while simplifying infrastructure setup.
ZenML vs Dataiku
Dataiku alternative: Open-source MLOps framework with portable Python pipelines and composable stack. Build production ML workflows with vendor-neutral flexibility and best-of-breed tool integration
ZenML vs Domino Data Lab
Domino Data Lab alternative: Open-source MLOps framework with portable pipelines and composable stack. Build production ML workflows with vendor-neutral flexibility and code-first portability
ZenML vs Metaflow
Metaflow alternative: Flexible ML orchestration with comprehensive MLOps. Accelerate ML using adaptable architecture and seamless integrations.
ZenML vs Valohai
Valohai alternative: Open-source MLOps framework with extensive integrations. Accelerate ML development using Python-based SDK, adaptable architecture, and existing infrastructure, while avoiding vendor lock-in.
ZenML vs Vertex AI
ZenML: an open-source alternative to Vertex AI Pipelines that keeps your MLOps stack portable across GCP, AWS, Azure, and on-prem
Broaden Your AI Orchestration Understanding with ZenML
Introducing the new Kitaru: from production traces to repeatable evals
The new Kitaru turns production traces you already collect into replayable test scenarios, expert-reviewed cohorts, and evaluators you can run on every change.
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.
Ready to Build Pipelines That
Aren't Tied to Azure ML?
Explore how ZenML maps common Azure ML concepts like pipelines, components, and registries to a portable, cloud-agnostic stack Learn how to migrate gradually: keep Azure ML where it's strongest while standardizing pipeline logic for multi-cloud flexibility See real-world patterns for swapping orchestrators and backends without rewriting workflows as your organization grows