Why your AI agents redo each other's work (and what fixes it)

When using multiple AI coding agents on the same project, you may have experienced issues where each agent independently makes decisions that later seem to undo or contradict the work of the other agent. This can lead to a scenario where you are essentially reliving the context shared between two windows, with one agent carrying the knowledge from one location to the next.

It's easy to blame the AI models themselves, as they are typically performing well. However, the root cause lies in the fact that the agents do not share a common understanding of the code they are working with.

The problem arises because, while the agents can access the same repository, they do not share the same context or reasoning behind the decisions they make. For instance, one agent might have determined how to structure the authentication flow, while another agent, reading the same files, might reach a different conclusion because it was not privy to that reasoning. This results in the agents repeatedly undoing each other's work, as if they are unaware of the other's actions.

Various solutions have been proposed to address this issue. Some individuals create files like CLAUDE.md or AGENTS.md to establish stable rules for the agents, while others attempt to manually copy context between different windows. Others attempt to increase the context window size, but these approaches do not address the core problem. The understanding remains confined to each agent's individual context and is not shared with the project as a whole.

The true solution lies in making the understanding of the project accessible to all agents. Instead of relying on chat history or external files, the understanding should be embedded within the project itself. When one agent commits a decision, grounded in the code it modifies, the next agent should inherit that decision without being explicitly told. By opening the project, the newly acquired knowledge becomes part of the overall understanding of the project.

One solution to this problem is Naive, which does not function as a coordination layer to schedule the agents' actions. Rather, it acts as a shared understanding that all agents inherit. In this way, the agents no longer need to independently redo each other's work because they already possess the collective knowledge of what has already been decided. Naive eliminates the need for separate communication channels or manual context sharing, as the agents work from a single, consistent picture of the project's state.