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.
After a benchmark on several solutions, we choose ZenML for its stack flexibility and its incremental process. We started from small local pipelines and gradually created more complex production ones. It was very easy to adopt.
Clément Depraz
Data Scientist at Brevo
Explore in Detail What Makes ZenML Unique
| Feature | ZenML | Dataiku |
|---|---|---|
| Workflow Orchestration | Yes Portable, code-defined pipelines that run on any orchestrator (Airflow, Kubeflow, local, etc.) via composable stacks | Yes Built-in visual Flow orchestrator with Scenarios for scheduling, event triggers, and conditional automation |
| Integration Flexibility | Yes Designed to integrate with any ML tool — swap orchestrators, trackers, artifact stores, and deployers without changing pipeline code | Not supported Rich built-in connectors (40+ data sources) and plugins, but integrations work within Dataiku's platform abstraction layer |
| Vendor Lock-In | Yes Open-source and vendor-neutral — pipelines are pure Python code portable across any infrastructure | Not supported Proprietary platform where visual Flows, Recipes, and Scenarios are tied to Dataiku DSS — migrating away requires reimplementation |
| Setup Complexity | Yes Pip-installable, start locally with minimal infrastructure — scale by connecting to cloud compute when ready | Not supported Enterprise setup requires Design, Automation, and API nodes with server provisioning. Cloud trial available but production is heavyweight |
| Learning Curve | Yes Familiar Python pipeline definitions with simple decorators — fewer platform concepts to learn for ML engineers | Yes Visual interface accessible to non-coders (analysts, business users). Extensive Academy training. But mastering the full platform takes time |
| Scalability | Yes Scales via underlying orchestrator and infrastructure — leverage Kubernetes, cloud services, or distributed compute | Yes Enterprise-grade scaling with in-database SQL push-down, Spark integration, Kubernetes execution, and multi-node architecture |
| Cost Model | Yes Open-source core is free — pay only for infrastructure. Optional managed service with transparent usage-based pricing | Not supported Enterprise subscription pricing (sales-led, custom quotes). Free Edition available for up to 3 users with limited production features |
| Collaborative Development | Yes Collaboration through code sharing, Git workflows, and the ZenML dashboard for pipeline visibility and model management | Yes Strong multi-persona collaboration with project wikis, discussions, shared dashboards, and role-based access across data scientists and analysts |
| ML Framework Support | Yes Framework-agnostic — use any Python ML library in pipeline steps with automatic artifact serialization | Yes Built-in AutoML covers scikit-learn, XGBoost, and TensorFlow/Keras. Code recipes support any framework installable in code environments |
| Model Monitoring & Drift Detection | Yes Integrates with monitoring tools like Evidently and Great Expectations as pipeline steps for customizable drift detection | Yes Built-in Model Evaluation Store, Unified Monitoring dashboard, and drift analysis for data, prediction, and performance drift |
| 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 Dataiku Govern module, audit logs, data catalog and lineage, LDAP/SSO, and regulatory compliance features |
| Experiment Tracking | Yes Integrates with any experiment tracker (MLflow, W&B, etc.) as part of your composable stack | Yes Built-in experiment tracking for AutoML with model comparison UI. Supports logging from scikit-learn, XGBoost, LightGBM, and TensorFlow |
| Reproducibility | Yes Auto-versioned code, data, and artifacts for every pipeline run — portable reproducibility across any infrastructure | Yes Managed code environments, project bundles for deployment, and Flow determinism. Requires discipline around data versioning |
| Auto Retraining Triggers | Yes Supports scheduled pipelines and event-driven triggers that can initiate retraining based on drift detection or data changes | Yes Native Scenarios with time-based schedules, event triggers, and conditional logic for automated retraining and deployment |
Code comparison
ZenML and Dataiku 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()# Dataiku DSS platform workflow
# Runs inside Dataiku's managed environment
import dataiku
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# Read input dataset from Dataiku's managed storage
dataset = dataiku.Dataset("customers_prepared")
df = dataset.get_dataframe()
X = df.drop("target", axis=1)
y = df["target"]
# Train model inside Dataiku's code recipe
model = RandomForestClassifier(n_estimators=100)
model.fit(X, y)
acc = accuracy_score(y, model.predict(X))
print(f"Accuracy: {acc}")
# Write predictions to output Dataiku dataset
preds = pd.DataFrame({"prediction": model.predict(X)})
output = dataiku.Dataset("predictions")
output.write_with_schema(preds)
# Multi-step orchestration uses visual Flows + Scenarios
# (configured through Dataiku's platform UI).
# AutoML, monitoring, and retraining are all managed
# within the proprietary DSS environment.
# Requires Dataiku server and enterprise license.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 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.
Build Portable ML Pipelines
With Full Stack Freedom
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 and version control Learn how to compose your ideal ML stack from best-of-breed tools while maintaining full portability across clouds