We have something that looks like this, where you have an orchestrator, and the orchestrator is in charge of driving the rollouts. The orchestrator holds a task back, which you can think of for now is just a simple prompt and answer. So, something like a math question and a corresponding numerical answer. Um the orchestrator will send this prompt to a model and then get an answer back. Then it will send the answer to a grader and have it be graded. So, once all of this is done, we want to improve our model based on that interaction or maybe like a batch of interactions. And the way we do that is through a training engine, which takes in the graded chats and produces a weight update. That weight update is then synced to some inference engines. And once those inference engines are updated, then we can start this entire process over again, where the orchestrator will have like new problems to um send to the model completion endpoint, and then you'll be able to get more chats, grade them, and train again. The key thing to note here is that the only thing you need for improving your model is the graded chats in some format, and once you have those, the training engine can compute weight updates to improve your model. Uh what's important here is that the chats are in a very specific format because we're sort of constraining everything to be inside of our training stack. So, in this simple setup for Q&A, you don't have anything living outside of the training stack. You You basically have the code of how to run the rollout and how everything is formatted, so it's like in a very controlled environment. However,