The Trust Curve: How Long Until Your Team Trusts the Agent
Six to twelve weeks at three different companies. The shape of the curve, what shifts it left, and the milestones that mean you have actually earned trust.
The shape of trust
Trust follows a sigmoid: slow start, accelerating mid-curve, asymptotic top. Slow start: weeks 1-3 (the team is checking the agent’s work, trust builds slowly because the team verifies everything). Acceleration: weeks 4-8 (cases the agent handles correctly outweigh cases it gets wrong, trust builds quickly). Asymptote: weeks 9-12 (trust plateaus, further trust requires expanding the agent’s scope).
- Sigmoid shape. Slow start, acceleration, asymptote; not linear.
- Weeks 1-3 verification phase. Team checks every output; trust builds slowly.
- Weeks 4-8 acceleration. Correct cases outweigh wrong; trust builds quickly.
- Weeks 9-12 plateau. Trust at scope ceiling; expand scope to grow further.
Milestones that mean trust
Three milestones mark the curve. First time the team relies on the agent’s output without independently verifying (weeks 4-6 in healthy teams); first time the team escalates an agent-flagged issue without re-investigating (weeks 6-8); first time someone says “let’s see what the agent thinks” before doing any investigation themselves (weeks 8-12).
- Trust without verifying. Weeks 4-6; team relies on output without independent check.
- Escalates without re-investigating. Weeks 6-8; agent’s flag is enough.
- “What does the agent think?” Weeks 8-12; agent is the first stop.
- Per-team milestone tracking. Documented when each milestone hits; supports continued investment.
What shifts the curve left
Three factors accelerate trust. Strong eval suite at launch (the team sees the agent passing tests; trust starts higher); visible reasoning, not just answers (the team can audit; trust builds faster); quick correction of early errors (the first wrong answer matters less than the response to it; transparent fixes build trust).
- Strong eval suite at launch. Team sees passing tests; trust starts higher.
- Visible reasoning. Not just answers; auditable; trust builds faster.
- Quick error correction. First wrong answer matters less than response; transparent fixes build trust.
- Per-launch trust investment. The pre-launch work pays back in the curve.
What pushes the curve right
Three patterns delay trust. Silent errors (the agent gets it wrong without flagging; the team discovers later; massive trust hit); inconsistent quality across similar cases (the team cannot predict when to trust; defaults to not); stakeholder pushback (“don’t trust the agent” from someone senior delays adoption by months).
- Silent errors. Wrong without flagging; discovered later; massive trust hit.
- Inconsistent quality. Team can’t predict when to trust; defaults to not.
- Stakeholder pushback. Senior “don’t trust” delays adoption by months.
- Per-pattern mitigation. Each delaying pattern has a counter; supports faster recovery.
Recovering from a trust hit
Recovery is the slowest part of the curve. After a serious agent error, trust drops back to week 1 levels and rebuilds slower; recovery requires transparent post-mortem, visible fixes, sustained quality for at least 4 weeks; some teams never fully recover and the agent gets retired (a new agent gets a fresh start with new expectations).
- Drops to week 1; rebuilds slower. The recovery curve is harder than the initial.
- Transparent post-mortem plus visible fixes. The recovery prerequisites.
- 4-week sustained quality. Re-earn trust; not faster.
- Some teams never recover. Agent retired; new agent gets fresh start with new expectations.