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.
Start locally without complicated setup hassle
- ZenML is available as a simple pip package that lets you run and track pipelines locally.
- ZenML integrates with your orchestration layer of choice, avoiding having to learn different paradigms for dev, staging, and prod.
- ZenML integrates with your orchestration layer of choice or can be extended with your own orchestration service.
Abstract away infrastructure complexity
- Most orchestrators assume some form of infrastructure knowledge to use them maximally — ZenML abstracts that complexity away.
- ZenML separates infrastructure setup like Docker building from the application logic, and automates the tedious parts.
- ZenML focuses on the handovers between MLOps Engineers, ML Engineers, and Data Scientists.
Switch between orchestrators depending on your context
- You can switch between different orchestration services with a single click — from dev to staging to production.
- The more engineering-minded in the team still retain control over their productionalization because the framework is extensible.
- ZenML handles the pain of packaging your code into Docker to be deployed to your orchestration service of choice.
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 | Argo Workflows |
|---|---|---|
| Workflow Orchestration | Yes ML-native pipelines with portable execution via stacks, while still supporting Kubernetes-based orchestration when needed |
Yes Kubernetes-native workflow engine with mature DAG/steps execution, retries, scheduling, and strong operational controls on K8s |
| Integration Flexibility | Yes Composable stack with 50+ MLOps integrations — swap orchestrators, trackers, and deployers without code changes |
Yes Runs virtually any containerized tool, but integrations are DIY — teams wire credentials, storage, and conventions manually |
| Vendor Lock-In | Yes Cloud-agnostic by design — stacks make it easy to switch infrastructure providers and tools as needs change |
Yes Runs on any Kubernetes cluster and is CNCF-governed open source — lock-in is primarily to Kubernetes itself, not a specific cloud |
| Setup Complexity | Yes pip install zenml — start locally and scale up by swapping stacks, avoiding immediate Kubernetes dependency |
Not supported Requires Kubernetes cluster plus Argo installation, RBAC config, artifact repository, and optional database for full value |
| Learning Curve | Yes Python-first and ML-first — reduces cognitive load for ML engineers who don't want to become Kubernetes experts |
Not supported Assumes Kubernetes fluency (CRDs, pods, namespaces, service accounts, storage) — ML teams often need platform help to adopt it |
| Scalability | Yes Delegates compute to scalable backends — Kubernetes, Spark, cloud ML services — for unlimited horizontal scaling |
Yes Built for parallel job orchestration on Kubernetes with parallelism limits, retries, and workflow offloading for large DAGs |
| Cost Model | Yes Open-source core is free — pay only for your own infrastructure, with optional managed cloud for enterprise features |
Yes Apache-2.0 and CNCF-governed with no per-seat or per-run pricing — costs are Kubernetes infrastructure and operations |
| Collaboration | Yes Code-native collaboration through Git, CI/CD, and code review — ZenML Pro adds RBAC, workspaces, and team dashboards |
Not supported UI and SSO support for multi-user setups, but collaboration is centered on workflow execution and logs — not ML experiment sharing |
| ML Frameworks | Yes Use any Python ML framework — TensorFlow, PyTorch, scikit-learn, XGBoost, LightGBM — with native materializers and tracking |
Yes Framework-agnostic at the runtime level — if it runs in a container on Kubernetes, Argo can orchestrate it |
| Monitoring | Yes Integrates Evidently, WhyLogs, and other monitoring tools as stack components for automated drift detection and alerting |
Not supported Monitors workflow execution well (statuses, logs, Prometheus metrics), but no production model monitoring or ML drift detection built in |
| Governance | Yes ZenML Pro provides RBAC, SSO, workspaces, and audit trails — self-hosted option keeps all data in your own infrastructure |
Yes Kubernetes-centric governance with namespacing, RBAC, and workflow archiving — but ML-specific audit trails require external systems |
| Experiment Tracking | Yes Native metadata tracking plus seamless integration with MLflow, Weights & Biases, Neptune, and Comet for rich experiment comparison |
Not supported No built-in experiment tracking — teams embed MLflow or W&B inside containers and standardize conventions manually |
| Reproducibility | Yes Automatic artifact versioning, code-to-Git linking, and containerized execution guarantee reproducible pipeline runs |
Not supported Workflows are rerunnable, but reproducibility depends on pinned containers, data versioning, and discipline — not enforced by default |
| Auto-Retraining | Yes Schedule pipelines via any orchestrator or use ZenML Pro event triggers for drift-based automated retraining workflows |
Yes CronWorkflows and webhook triggers enable automated retraining runs — model promotion and registry logic left to your stack |
Code comparison
ZenML and Argo Workflows 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 hera.workflows import Steps, Workflow, WorkflowsService, script
@script()
def preprocess() -> str:
print("s3://ml-artifacts/datasets/processed.csv")
@script()
def train(data_uri: str) -> str:
print("s3://ml-artifacts/models/model.pkl")
@script()
def evaluate(model_uri: str):
print(f"evaluating {model_uri}")
with Workflow(
generate_name="ml-train-eval-",
entrypoint="steps",
namespace="argo",
workflows_service=WorkflowsService(
host="https://localhost:2746"
),
) as w:
with Steps(name="steps"):
data = preprocess()
model = train(arguments={"data_uri": data.result})
evaluate(arguments={"model_uri": model.result})
w.create()
# Requires Kubernetes cluster + Argo installation.
# No built-in experiment tracking, model registry,
# artifact lineage, or reproducibility guarantees.
# ML lifecycle layers must be built separately.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 Orchestrators: Book Your Free ZenML Strategy Talk
Orchestrator Showdown
Explore the Advantages of ZenML Over Other Orchestrator Tools
ZenML vs Apache Airflow
ML-optimized workflow management. Enhance scalability and usability with comprehensive features designed for ML pipeline orchestration.
ZenML vs Dagster
Dagster alternative: Streamline ML ops with intuitive pipelines. Seamless integrations and experiment tracking for efficient ML workflow management.
ZenML vs Databricks
Databricks alternative: Flexible ML orchestration without vendor lock-in. Accelerate ML with lightweight, adaptable workflows across multiple clouds.
ZenML vs Flyte
Flyte alternative: Agile ML pipeline orchestration. Accelerate workflows with intuitive tools, seamless MLOps integration, and rapid iteration.
ZenML vs Kedro
Kedro alternative: Scalable, user-friendly ML framework. Streamline operations with robust features for efficient project management and deployment.
ZenML vs Kubeflow
Kubeflow alternative: Lightweight ML pipeline management. Simplify MLOps with flexible, user-friendly workflows across various environments.
ZenML vs Prefect
Prefect alternative: ML-centric pipeline orchestration. Streamline workflows with intuitive design, experiment tracking, and MLOps integrations.
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 Turn Argo-Style Workflows
into Portable ML Pipelines?
See how ZenML adds ML-native metadata, lineage, artifact tracking, and more on top of your existing Kubernetes infrastructure Explore Kubernetes-friendly execution without writing everything as CRDs and YAML: keep your workflow logic Python-first Learn how ZenML's stack approach plugs into experiment trackers and deployers so you don't have to build an MLOps platform around Argo