Open models, end to end: Introducing Crusoe Managed RL and Managed MLflow
Agents are only as good as their models. Crusoe Managed RL and Managed MLflow, now in private preview, join Managed Inference and Serverless Fine-Tuning so teams can customize, serve, evaluate, and improve open models on Crusoe Cloud under one API key.
.jpg)
Over the last year, open models have gone from experiments to production. On OpenRouter, their share of tokens doubled, from about a third in late 2025 to more than two-thirds by mid-2026. GLM 5.3 Flash processed 55 trillion tokens there last month, Kimi K3 is moving into legal, finance, and medical work, and U.S. labs are all in, with Thinking Machines Lab’s Inkling and Reflection AI’s Beam. Open models are now a key part of the foundation.
On that foundation, companies are building agents. And an agent is only as good as its models. The models that reason and act for your agent have to know your business: your processes, your data, your rules. They have to run at scale. And that’s just the start. You need evals to prove they work before customers see them, observability to catch where they succeed and fail, and a way to feed real-world traces back into training so they keep improving. Most teams stitch this together from separate tools and infrastructure. It’s slow, it’s expensive, and it keeps engineers from what matters: building better models and agents.
That's why, starting today, Crusoe Cloud supports open models across the entire lifecycle, with two new products: Crusoe Managed RL and Crusoe Managed MLflow, both in private preview. They build on Crusoe Managed Inference and Crusoe Serverless Fine-Tuning, which we launched earlier this year and are already GA.
Together, they cover every step, from customizing a model to serving, measuring, and improving it. And the foundation is proven: teams like Thinking Machines Lab, Ollama, Base44, Fireworks, Roboflow, and SpAItial are already building on Crusoe Cloud.
.png)
Crusoe Serverless Fine-Tuning or Crusoe Managed RL: Two levels of the same stack
Serverless Fine-Tuning and Managed RL are two levels of the same stack: same open models, same API key, same storage for the adapters. What differs is what you give the model and how much of the training loop you own. Serverless Fine-Tuning takes a dataset: examples of the answers you want, which the model learns to reproduce. Managed RL takes a judgment: you define what a good outcome looks like as a reward, and the model learns to find answers you never wrote down. A dataset teaches facts and format. A reward conveys taste.
Serverless Fine-Tuning is the curated path. Upload a JSONL dataset, pick a base model, and create a job with one API call. You control the hyperparameters, from learning rate and epochs to LoRA rank, and get back a checkpoint you can serve right away.
Managed RL goes one level down. Instead of a job, you get the primitives of a training loop: sample, score with your own reward, run forward and backward passes with the loss you choose, step the optimizer, save weights, and repeat. The loop is a Python script on your laptop. Crusoe runs the GPUs, the sharding, and the serving behind the API, so there is still no cluster to manage. Take this path when the recipe is what you are working on: GRPO against a verifiable reward, a custom curriculum, an agent task with its own definition of success, or supervised training where you decide which tokens carry the loss.
Both paths produce LoRA adapters on the same models and deploy through the same endpoints, so a team can start with a fine-tuning job and graduate to RL without changing anything else.
How Crusoe Managed RL is different
Opinionated RL and fine-tuning products tend to make the same trade: a short list of models, a fixed set of recipes, few ways to serve the result, and experiment tracking left to you. Crusoe is taking a different position.
Your loop, your rules: Managed RL is Tinker-compatible, so a loop written with one of the open-source Tinker recipes runs on Crusoe Cloud as-is. You write the loop, the reward, and the stopping rule in plain Python. GRPO, DPO, or your own curriculum: they’re all just loops.
No lock-in: The cookbooks and tooling the community is building around Tinker work here unchanged, and anything you build moves with you.
Train what you serve: Managed RL uses the same open model families as Serverless Inference, so you train the model you were already evaluating. Then serve it on Self-Serve Deployments or a Tailored Deployment, with the AI Gateway in Managed MLflow shifting traffic between versions as you iterate.
One platform: Managed MLflow tracks every RL run’s rewards, losses, checkpoints, and parameters next to your fine-tuning jobs and evals, and turns production traces into the next run’s dataset, all under one API key.
MLflow, fully managed on Crusoe Cloud
Managed MLflow brings MLflow to Crusoe Cloud as a fully managed service. Developers already rely on MLflow to track experiments, evaluate models, and trace agents in production. But self-hosting means standing up a tracking server, a backend database, and artifact storage, then owning authentication, scaling, upgrades, and security patches yourself.
Managed MLflow takes that operational work off your plate, so your experiments, evaluations, and traces live right alongside the models you train and serve on Crusoe Cloud from day one. Already using MLflow? Set your tracking URI with a single environment variable, and your existing code just works. And your inference and training metrics show up there automatically, with no extra code.
"MLflow is the open source standard for the AI lifecycle, with 60M+ monthly downloads and 1,000+ contributors. We're pleased to see Crusoe bring Managed MLflow to Crusoe Cloud, so developers can focus on building, not on operating tracking infrastructure." - Alkis Polyzotis, Senior Software Engineer, Databricks
The open model lifecycle on Crusoe
Getting an open model into production isn’t a one-time step. It’s a loop, and every pass should leave you with a better model than the one before. Here’s how we cover each phase:
- Choose: Pick a base model and test it on your own tasks, not just leaderboards. Leading open models are one API call away on Crusoe Cloud, including DeepSeek, GLM 5.3, Qwen, Nemotron, GPT-OSS, Gemma, and Llama. Serverless Inference in Crusoe Intelligence Foundry gives you an OpenAI-compatible, pay-per-token endpoint, so you can test candidates before you commit to one.
- Customize: There are two ways to adapt a model to your domain. Crusoe Serverless Fine-Tuning teaches it what you know: you bring a dataset and pick a base model, and we handle the GPUs, the training job, and the checkpoints. Managed RL teaches it to make the right decisions: you define the task and what a good outcome looks like, and we run the rollouts and policy updates. Either way, there’s no cluster to manage, and the weights are yours.
- Evaluate: A customized model is only better if you can prove it. Managed MLflow lets you build evaluation datasets from your real tasks, score outputs with built-in and custom LLM judges running on Crusoe-hosted models, and compare each new checkpoint side by side with the base model.
- Deploy: Serve the model the way your workload demands in Crusoe Intelligence Foundry. Serverless Inference gives you instant, pay-per-token access. Self-Serve Deployments give you dedicated endpoints with predictable costs. Tailored Deployments add bespoke, engineering-led optimization on Crusoe’s inference engine, powered by MemoryAlloyTM technology. And as you iterate, the AI Gateway in Managed MLflow gives your application a single endpoint and shifts traffic between model versions with no code changes.
- Observe: See what the model and your agents actually do. Managed MLflow tracing captures every request as a trace, with the inputs, each step, every tool call, the output, latency, and token usage. It plugs into leading agent frameworks, including LangChain, LangGraph, the OpenAI Agents SDK, PydanticAI, and LiteLLM, usually with a single autolog call. Traces are tagged by user, session, and environment, so you can find the exact step where something went wrong.
- Improve: Production traces are your best training data. Filter the traces where the model fell short, attach human feedback, and curate them into new evaluation and training datasets. Feed those into the next fine-tuning or RL run, compare it against the last one in the same experiment, and promote it when it wins. Every pass through the loop should leave you with a better model.
Underneath all six phases above sits one record of truth. Managed MLflow experiment tracking records every run, evaluation, and deployed version, along with the parameters, metrics, and lineage that connect them, so any model in production can be traced back to the data and recipe that produced it.
Dashboards show the health of your jobs, endpoints, models, and agents in one place. You work in the MLflow SDK and UI you already know, authenticated with your Crusoe project API key, and your weights and data stay in your own storage.
Get started
Managed RL and Managed MLflow are now in private preview. If you're building agents on open models and want a model that keeps getting better, from your first RL run to live traffic and back again, we'd love to work with you. Spots are limited while we shape both products with early teams.
Frequently
asked questions
Is fine-tuning the same as reinforcement learning?
Fine-tuning and reinforcement learning both adapt an open model, but they learn from different inputs. Fine-tuning takes a dataset of example answers, which the model learns to reproduce. Reinforcement learning takes a reward that defines a good outcome, so the model learns to find answers no one wrote down. On Crusoe Cloud, Serverless Fine-Tuning and Managed RL both produce LoRA adapters on the same models and endpoints.
Can MLflow be used for LLMs?
MLflow can be used for LLMs and agents, with tools to trace every request, evaluate outputs with LLM judges, and track experiments. MLflow describes itself as the largest open-source AI engineering platform for agents and LLMs. MLflow tracing plugs into agent frameworks such as LangChain, LangGraph, the OpenAI Agents SDK, PydanticAI, and LiteLLM, usually with a single autolog call.
How can I evaluate the performance of an LLM?
Teams evaluate an LLM by testing it on their own tasks, not just leaderboards, and comparing each new version against the base model. In Crusoe Managed MLflow, teams build evaluation datasets from real tasks, score outputs with built-in and custom LLM judges running on Crusoe-hosted models, and compare each new checkpoint side by side with the base model.
What is the AI model lifecycle?
The AI model lifecycle is a repeating loop: choose a model, customize it, evaluate it, deploy it, observe it in production, and improve it, with each pass producing a better model than the last. On Crusoe Cloud, production traces captured in Managed MLflow become the evaluation and training datasets for the next fine-tuning or reinforcement learning run.
.jpg)
