something deeply deficient on the other. And that's what agents are. Let me walk you through an example of how many times we re-explain things in a simple interaction. We have four repos, UI, module one, module two, and platform. I want to change the UI and propagate the change through the system. Okay? First, we change the UI library. Say we, I don't know, change a button or whatever. That's the first explanation, unavoidable. We have to express the intent, okay? Then we publish it. We go to module one, and we have to re-explain what just has happened in the UI library, so it can consume the package here. Note that that's often a different person, right? Every box in this diagram can be done by a different person. And then we discover that the published UI library doesn't work with module one. So, we go back to UI, and we have to re-explain the original change and the issue. Right? Because it's a new agent, it doesn't know the original change. It obviously doesn't know about the issue. Let's say we fix it, right? And uh publish it again. We go and again we explain the new change in the context of module one, same module. I mean, do the same for module two again. And then we go to the platform repo and we explain everything fits together and we implement the change there. Let's imagine a week after release, a bug appears in the UI component and we have to fix it. So we start an agent in the UI repo. And we have to explain again the original change from a week ago and this production issue we're seeing. So we have seven explanations for what essentially is one change. And also it may not be one person making all these seven explanations, but they still occurred, right? So that's very very typical with agents.