The New Meta(flow): Plan and Build in Kilo, Deploy on the Anaconda Platform

For most Python teams, the distance between “I have an idea for a pipeline” and “that pipeline is running in production” is still measured in days, not minutes. You prototype in a notebook, rewrite the logic into something deployable, wire up infrastructure, and hope nothing breaks on the way from your laptop to the cloud.

Now that Kilo is part of Anaconda, that distance gets a lot shorter. Kilo handles the plan and build side of the equation. The Anaconda Platform handles the run and deploy side. Together, they cover the full path from idea to production pipeline without forcing you to switch mental frameworks halfway through.

Two tools that were already speaking the same language

Metaflow, the open-source framework at the core of the Anaconda Platform, structures work as a graph of steps. You write plain Python, decorate functions with @step, and Metaflow handles the versioning, scaling, and orchestration underneath. It’s a framework built around a simple idea: let people write code the way they already think, and deal with the infrastructure automatically.

Kilo’s agent modes map onto that same shape almost exactly. Kilo’s Plan mode is where an agent sketches the graph before writing a line of code. Code mode is where each step gets implemented. Debug mode catches the inevitable broken artifact or malformed foreach input. Review mode closes the loop before anything ships. Once you’ve built the pipeline, you can deploy quickly on the Anaconda Platform. You’re not translating between two different ways of working. You’re using one tool to think through a flow, and another to run it.

What the new flow actually looks like

Say you want to build something that scans every repo in your org, checks dependencies, and serves the results as a live report. Here’s how that goes from nothing to running:

Plan in Kilo. Sketch the steps: list repos, scan each one in parallel, aggregate the findings, deploy a small dashboard. Kilo’s Plan mode turns that into an actual implementation plan instead of a whiteboard sketch that never gets built.

Build in Kilo. Code mode writes the FlowSpec class, the @step functions, the foreach fan-out across repos. If something’s off, like a manifest parser choking on a weird file format, Debug mode catches it before you’ve wasted a cloud run finding out the hard way.

Deploy on the Anaconda Platform. Once the flow works locally, the same code runs at scale with --with kubernetes, and the @app_deploy decorator turns the finished artifact into a live FastAPI service, using the exact same image and code package the flow itself ran on. No separate deployment pipeline, no “does this work the same way in prod” surprises.

That last part matters more than it sounds. The Anaconda Platform’s Deployments API means the same artifact that got versioned during your flow run is what gets served online, with full lineage back to the run that produced it. You’re not exporting a model and hoping the serving environment matches. It’s the same environment, because it’s literally the same image.

Why this is bigger than one demo

This isn’t just about wiring one flow together. It changes what “building on Kilo” means for anything data or ML adjacent. Kilo already gives you 500+ models to choose from and agent modes built for iterating fast. The Anaconda Platform gives you the compute layer, the artifact registry, and the path to production that Netflix originally built Metaflow to solve, now running in your own cloud account with SOC2 and HIPAA compliance built in.

Put together, a developer can go from “I have an idea for a data pipeline” to “it’s deployed, versioned, and serving traffic” without leaving a workflow that starts and ends in code they wrote themselves. That’s the actual promise of moving at Kilo Speed: not just writing code faster, but closing the entire loop from prototype to production without the usual friction in between.

If you’re already using Kilo for day-to-day development, this is the natural next step: plan the flow, build it with your agent modes, and let the Anaconda Platform take it the rest of the way.