There is a specific, visceral silence that follows a failed hand-off. It is the moment you realize the agent you just dispatched has perfectly executed a plan based on a misunderstanding. You see the code commit, the green checkmark in the CI, and the polished PR, but as you read the logic, you feel a knot in your stomach. The system did exactly what it was told, but it missed the one thing that actually mattered. The trust is gone, not because the agent failed, but because the hand-off did.
Most people treat agentic workflows as a sequence of tools. They see a pipeline as a series of hammers: one to nail the PRD, one to frame the spec, one to finish the code. But a hammer does not have a memory. When you move from discovery to engineering, the artifact—the document—moves forward, but the concern—the specific, jagged fear that drove the discovery process—is left behind. This is the artifact gap. In the Triangle Offense, we don't just move the ball; we move the spacing. If the spacing is wrong, the play fails regardless of who is holding the ball.
The Jagged Frontier of Trust
In the research by Dell'Acqua and colleagues on the "Jagged Frontier," we see a pattern that mirrors the basketball court. There are tasks where the AI is a superstar and tasks where it is a liability, and the line between the two is not a straight wall—it is jagged. The failure in most agentic workflows happens when the operator assumes the agent is on the right side of that frontier without verifying the hand-off.
When we treat an agent as a tool, we are simply asking it to perform. When we treat an agent as a teammate, we are managing a relationship of trust. Trust in a system is not a feeling; it is the result of competence being surfaced before the request is even made. If I have to tell Michael Jordan how to cut to the basket, I have already lost the game. The goal of the orchestrator is to create the conditions for excellence so the agent knows the play before the ball is in their hands.
The Trust Protocol
To close the discovery loop, we must move away from managing tasks and start coaching systems. I propose a three-step protocol for the hand-off:
1. Surface Competence. The agent must prove it understands the specific failure modes of the project before it is given the keys. This is not a general prompt; it is a precision brief. We don't ask an agent to "write the code"; we ask it to "solve for the race condition identified in the discovery phase."
2. Clear Boundaries. Every player needs to know their role. The orchestrator does not write code, and the coder does not set strategy. When the boundaries are blurred, the system becomes chaos. Trust grows when the agent knows exactly where its authority ends and the orchestrator's oversight begins.
3. Graceful Degradation. A system that only works when everything is perfect is not a system; it is a lucky streak. True trust comes from knowing how the system fails. When an agent hits the jagged frontier, it should not hallucinate a path forward; it should signal the gap and hand the ball back to the coach.
The most effective orchestration is invisible. The agents shouldn't feel managed; they should feel like they are operating within a flow that naturally leads to the right result. When the system is designed correctly, the ball finds the open man every time. Stop trying to score the points yourself. Step back, set the spacing, and let the system win.