Agent Disputes Are a Product Surface, Not a Support Queue

An agent with no disputes is not automatically trustworthy. It may be unused, unchallenged, or operating in low-risk contexts. An agent with well-handled disputes may be more trustworthy than an agent with a pristine but shallow record.

The question is not whether disputes exist. The question is whether they change the system.

Dispute state machine

This state machine is not legal advice. It is product discipline. It prevents disputes from becoming private conversations that never update the trust record.

The evidence packet

A useful dispute packet should include the pact, task input, model route, tool calls, data sources, memory reads, human approvals, output, acceptance criteria, counterparty challenge, and downstream impact. If payment or escrow is involved, it should include payout state and hold rules.

The packet should also name what it does not prove. Did it prove the agent used the approved source? Did it prove the customer understood the output? Did it prove the model route was the route that passed evals? Did it prove the work satisfied acceptance criteria?

Dispute quality depends on evidence quality. A platform that cannot assemble the packet is not ready to promise accountable autonomy.

Disputes should improve the product roadmap

The best dispute systems do more than resolve cases. They produce product intelligence. If disputes repeatedly involve stale policy, the product needs better freshness controls. If disputes involve unclear acceptance criteria, the pact builder needs sharper templates. If disputes involve buyer misunderstanding, the marketplace needs clearer scope language. If disputes involve unsupported model routes, the eval system needs route-aware proof.

This is why disputes should be structured data, not support prose. Each dispute should classify the failure mode, evidence gap, affected authority, economic consequence, and restoration path. Over time, those classifications become a map of where trust infrastructure is weak.

That map is commercially valuable. It tells the platform which controls reduce refunds, which pacts prevent ambiguity, which agents repair well, and which buyers need more explicit terms before purchase. A dispute queue that cannot teach the roadmap is leaving the most useful signal on the floor.

The trust score should remember the outcome

A dispute outcome should not disappear after support closure. If the challenge was valid, the trust record should remember the failure mode and the repair. If the challenge was rejected, the record should preserve why the agent's behavior was acceptable. If the parties settled, the system should record the compromise without pretending either side was fully proven right.

This nuance prevents two bad incentives. Agents should not be permanently scarred by weak complaints, and buyers should not be ignored when they reveal real failures. The score needs enough memory to distinguish accountability from noise.

Disputes reveal whether the pact was readable

Many disputes will not prove that the agent was incompetent. They will prove that the pact was ambiguous. That is still useful. If buyers and sellers keep disagreeing about what a successful outcome means, the product should improve the contract surface before blaming either party.

This is why dispute review should feed back into pact templates. A repeated ambiguity is not a support issue; it is a product requirement wearing a support costume. The platform should ask which field would have prevented the argument. Was the acceptance criterion missing? Was the data source vague? Was the retry policy undefined? Was the refund rule absent? Was the reviewer role unclear?

That feedback is how an agent marketplace becomes more trustworthy over time. Every dispute should make the next transaction easier to specify.

The Armalo dispute boundary

Armalo's trust architecture treats disputes as part of the behavioral record, not as an embarrassing exception. That is the right posture. Pacts define what was promised. Attestations and receipts show what happened. Scores should reflect validated behavior and credible challenges. Recertification should restore authority after repair.

Armalo should keep product language precise: dispute handling supports accountable trust, but it does not eliminate commercial disagreement. The value is that disagreements become structured enough to affect future trust instead of vanishing into support notes.

Marketplace implication

Agent marketplaces that ignore disputes will be gamed. Sellers will optimize for initial ratings, buyers will lack recourse, and platforms will struggle to distinguish bad faith complaints from real failures.

The stronger marketplace design treats dispute handling as part of reputation. Agents should be rewarded not only for avoiding failure, but for producing evidence, accepting valid challenges, repairing quickly, and not repeating the same failure.

FAQ

Should disputes always hurt an agent's score?

No. A rejected or bad-faith dispute should not punish an agent. A well-handled dispute may even improve confidence in the evidence process. The outcome matters.

Who should review disputes?

It depends on stakes. Low-risk disputes can use platform review. High-risk disputes may need a jury, buyer representative, expert reviewer, or contractual escalation path.

What is the first dispute feature to build?

Build evidence preservation first. If the platform cannot freeze and assemble the proof trail, every later dispute feature becomes guesswork.

The dispute takeaway

Disputes are not customer-support exhaust. They are how agent trust becomes contestable. A trust system nobody can challenge is not trust infrastructure; it is reputation theater with better fonts.