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.
Our data scientists are now autonomous in writing their pipelines & putting it in prod, setting up data-quality gates & alerting easily
François Serra
ML Engineer / ML Ops / ML Solution architect at ADEO Services
Explore in Detail What Makes ZenML Unique
| Feature | ZenML | Domino Data Lab |
|---|---|---|
| Workflow Orchestration | Yes Provides portable, code-defined pipelines that run on any orchestrator (Airflow, Kubeflow, local, etc.) via composable stacks | Yes Offers Domino Flows (built on Flyte) with DAG orchestration, lineage tracking, and a platform monitoring UI |
| Integration Flexibility | Yes Designed to integrate with any ML tool — swap orchestrators, trackers, artifact stores, and deployers without changing pipeline code | Not supported Broad enterprise integrations (Snowflake, Spark, MLflow, SageMaker), but consumed through Domino's platform abstraction |
| Vendor Lock-In | Yes Open-source and vendor-neutral — pipelines are pure Python code portable across any infrastructure | Not supported Proprietary platform with moderate lock-in; uses Flyte and MLflow internally but ties workflows to Domino's control plane |
| Setup Complexity | Yes Pip-installable, start locally with minimal infrastructure — scale by connecting to cloud compute when ready | Not supported Enterprise deployment spectrum from SaaS to on-prem/hybrid, requiring Platform Operator and Kubernetes infrastructure |
| Learning Curve | Yes Familiar Python-based pipeline definitions with simple decorators; fewer platform concepts to learn | Yes Cohesive UI lowers barrier for data scientists, but many platform concepts (Projects, Workspaces, Jobs, Flows, Governance) |
| Scalability | Yes Scales via underlying orchestrator and infrastructure — leverage Kubernetes, cloud services, or distributed compute | Yes Enterprise-grade scaling with hardware tiers, distributed clusters (Spark/Ray/Dask), and multi-region data planes |
| Cost Model | Yes Open-source core is free — pay only for infrastructure. Optional managed service for enterprise features | Not supported Enterprise subscription pricing geared toward large organizations, with deployment options ranging from SaaS to on-prem |
| Collaborative Development | Yes Collaboration through code sharing, version control, and the ZenML dashboard for pipeline visibility | Yes Strong collaboration with shared Projects, interactive Workspaces, project templates, and model cards |
| ML Framework Support | Yes Framework-agnostic — use any Python ML library in pipeline steps with automatic artifact serialization | Yes Containerized environments support any framework; validated for scikit-learn, PyTorch, Spark, Ray, and more |
| Model Monitoring & Drift Detection | Yes Integrates with monitoring tools like Evidently and Great Expectations as pipeline steps for customizable drift detection | Yes Built-in monitoring with statistical tests (KL divergence, PSI, Chi-square), scheduled checks, and alerting |
| Governance & Access Control | Yes Pipeline-level lineage, artifact tracking, RBAC, and model control plane for audit trails and approval workflows | Yes Enterprise-grade governance with policy management, automated evidence collection, unified audit trail, and compliance certifications |
| Experiment Tracking | Yes Integrates with any experiment tracker (MLflow, W&B, etc.) as part of your composable stack | Yes MLflow-backed experiment tracking with autologging and manual logging, integrated into the platform UI |
| Reproducibility | Yes Auto-versioned code, data, and artifacts for every pipeline run — portable reproducibility across any infrastructure | Yes Strong reproducibility via environment snapshots, Flows lineage/versioning, and Git-based projects |
| Auto Retraining Triggers | Yes Supports scheduled pipelines and event-driven triggers that can initiate retraining based on drift detection or performance thresholds | Yes Scheduled Jobs and Flows with API-driven triggers; requires wiring monitoring alerts to job/flow execution |
Code comparison
ZenML and Domino Data Lab side by side
from zenml import pipeline, step, Model
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
@step
def ingest_data() -> pd.DataFrame:
return pd.read_csv("data/dataset.csv")
@step
def train_model(df: pd.DataFrame) -> RandomForestClassifier:
X, y = df.drop("target", axis=1), df["target"]
model = RandomForestClassifier(n_estimators=100)
model.fit(X, y)
return model
@step
def evaluate(model: RandomForestClassifier, df: pd.DataFrame) -> float:
X, y = df.drop("target", axis=1), df["target"]
return float(accuracy_score(y, model.predict(X)))
@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)
accuracy = evaluate(model, df)
drift = check_drift(df)
# Runs on any orchestrator (local, Airflow, Kubeflow),
# auto-versions all artifacts, and stays fully portable
# across clouds — no platform lock-in
ml_pipeline()# Domino Data Lab platform workflow
# Runs inside Domino's managed environment
import mlflow
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# MLflow tracking is pre-configured in Domino
mlflow.autolog()
# Data loaded from Domino datasets or mounted volumes
df = pd.read_csv("/domino/datasets/local/dataset.csv")
X, y = df.drop("target", axis=1), df["target"]
with mlflow.start_run():
model = RandomForestClassifier(n_estimators=100)
model.fit(X, y)
acc = accuracy_score(y, model.predict(X))
mlflow.log_metric("accuracy", acc)
mlflow.sklearn.log_model(
model, "model",
registered_model_name="my_model"
)
print(f"Accuracy: {acc}")
# Multi-step orchestration uses Domino Flows (Flyte-based)
# defined separately. Monitoring, drift detection, and
# retraining configured through Domino's platform UI.
# Runs only within the Domino platform environment.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 Azure ML
Looking for an open-source alternative to Azure ML Pipelines? ZenML builds portable ML pipelines across clouds without vendor 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 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.
Build Portable ML Pipelines
Without Platform Lock-in
Explore how ZenML's open-source framework can simplify your ML workflows with a flexible, start-free approach Discover the ease of building reproducible, production-grade pipelines with familiar Python code Learn how to compose your ideal ML stack while maintaining full portability across clouds and tools