I rarely ask one AI to carry a project from beginning to end now.
One model handles difficult judgment. Another handles heavy development. A third runs long-lived, lower-cost checks and scheduled tasks. Their abilities, prices, limits, and tool permissions differ. It is natural to use them as different kinds of colleagues.
It can feel like assembling a small team for the project.
More teammates create another problem.
Each AI sees part of the material and can give a plausible explanation. A project can still have only one current judgment: what problem it is solving now, which paths have been abandoned, which statements remain exploratory, and which changes require human confirmation.
Without that shared state, several AIs are taking turns reconstructing the project.
Code projects already have an order
Code projects can be chaotic too. They still have repositories, commits, pull requests, tests, and runnable results.
When a new person or agent takes over, they can inspect what changed, whether tests passed, and which commit introduced a problem. Git does not make the judgment for a team. It preserves traces of the judgment.
Many agent collaboration patterns grew from this world: task decomposition, code review, testing, rollback, and workspace isolation. They assume a project has a clear deliverable that can run, fail, or pass acceptance.
Some deliverables cannot explain the project
Strategy, marketing, content, research, proposals, and operations often work differently.
They can end in a plan, article, slide deck, or mechanism. Those artifacts record the final version. They rarely tell the next person:
- why the direction changed from A to B;
- why a promising path was dropped;
- which information was still a hypothesis;
- which changed premise should trigger a full review.
The difficulty in this work often appears before execution. Someone has to define the problem, then decide the boundaries, trade-offs, and standards of judgment. That part is often the most valuable work.
I call it judgment-heavy knowledge work.
This does not mean that programmers do not make judgments or that strategists do not execute. In some projects, the core difficulty can be tested through a runnable artifact. In others, the core difficulty is forming a good enough direction while the information remains incomplete.
Multi-agent handoffs make the gap larger
When one AI heads in the wrong direction, a person can still correct it within the same conversation.
When several AIs hand work off, the error can be quieter. A later agent reads an old summary and treats it as current fact. It produces a new plan. The next agent takes that plan as project consensus.
No one has to make an obvious mistake. Each step can look reasonable. The project can still move along an expired judgment.
That is why I have started preserving judgment records inside projects. They do not make decisions for people. They retain what matters: who made a judgment, under what conditions, what evidence supported it, what remains unconfirmed, and what should reverse it.
The Institute is less concerned with whether memory features are strong enough. The harder question is whether a person can still see where their judgment was changed when several AIs can write, summarize, and recommend the next step.
What does the person keep?
Multi-agent collaboration does not automatically weaken the person’s role. It concentrates that role into fewer and more consequential places.
No one needs to inspect every line of every output. A person still needs to retain a few things:
- what the project is trying to solve;
- which boundaries cannot be crossed;
- which inferences cannot be treated as facts yet;
- what results would change the original judgment;
- who gives the final approval to continue.
If these are also maintained by the AIs alone, the project may look smooth. It becomes harder to tell which decisions were actually yours and which only sound like decisions because a model wrote them convincingly.
Future human-AI collaboration may involve more than choosing the strongest model. A more common picture is one person coordinating several intelligent systems inside the same project.
Then the most basic question may be this:
> When three AIs all say they understand the project, who can show that they understand the same thing?
This is a collaboration problem already taking shape. Non-coding work does not yet have a mature answer.
Institute note
This is an observation from long-running multi-model project work, not a user-research finding. “Judgment-heavy knowledge work” is a working category used here to discuss how agents can collaborate on strategy, content, marketing, research, operations, and proposals.
What we are testing
We are using FlowGrid to test this approach locally: retaining the current judgment, rejected paths, unverified assumptions, review boundaries, and evidence sources in the project so the next person or AI can inspect and continue it.
It remains an experiment, not a proven solution to multi-agent collaboration. You can review the code and documentation and decide whether it fits your project.