Why PTSO recommended suede loafers in the rain.

I picked clothes because I could check the answers

PTSO (Put That Sh*t On) is a wardrobe recommendation system. I give it a city; it reads the weather and my closet, then returns ranked outfits built from clothes I own. I chose a small, personal domain because I could verify every recommendation while I learned the protocols.

The request path used four agents: an orchestrator accepted the city, a weather agent fetched the forecast, a wardrobe agent found appropriate garments, and an outfit agent composed the result. MCP connected agents to data and tools. A2A connected agents to one another. Google ADK provided the agent framework.

The failure passed every check

PTSO recommended suede loafers on a rainy day. The explanation was fluent and the shoes were valid against every field the system stored: formality, palette, availability, season, and the rest of the garment record. The missing fact was the one that mattered. None of those fields could express what rain does to suede.

I tried the usual fixes. A better prompt improved that example but not the next unseen constraint. A stronger model guessed better without making the domain complete. More agents only created more components that could improvise over the same missing knowledge. The failure came from an incomplete domain model.

The missing contract

MCP and A2A did their jobs. Requests arrived, tools ran, and agents returned responses. But a successful exchange only proved that the message moved. The agents still needed a shared vocabulary, the same constraints, and a way to justify each conclusion.

I rebuilt the domain as an explicit ontology, which Tom Gruber defines as an explicit specification of a conceptualization. I treated it as a rulebook for the data.

Vocabulary

A closed set of terms. A model-emitted value outside that set is an error.

Semantics

Relationships that separate different wording from different meaning.

Constraints

Conditions that cannot be true together, including material and weather conflicts.

Provenance

The source and timestamp attached to every fact used in a decision.

Inference

The exact conclusions the system may derive and the rule that licenses each one.

Every conclusion names its rule

In the rebuilt system, derived relationships carry the rule that produced them. When PTSO rejects a garment, it points to the facts and the rule that fired.

Projections have a maximum age of 120 seconds. Older data is treated as absent. When required facts are missing, constraints conflict, or no rule licenses an inference, the system refuses to return an outfit. A refusal makes missing or conflicting evidence visible.

The model did less, and the system got better

The first version asked the model to interpret the request, recall the domain, apply rules, and write the answer. The next version moved rules into code. The ontology-backed version moved domain truth into the contract, leaving the model to handle language and assembly.

Replacing model round trips with contract evaluation reduced latency and model cost while making behavior inspectable. Those numbers describe PTSO alone.

I turned the build into a conference talk

I turned the build and its failure into The Put That Sh*t On Agent: Building Multi-Agent AI Systems That Actually Talk to Each Other. I delivered the talk at RenderATL 2026 and am scheduled to present it at Commit Your Code. The talk asks one question that generalizes beyond a wardrobe: which decisions belong to a model, and which need an enforceable contract?

When I would use this again

A formal ontology earns its cost when wrong answers are expensive, the domain contains constraints the data model cannot express, a decision must be explained later, or several agents must agree on the meaning of a term. I skip it while the domain is changing quickly or when an occasional wrong answer has little consequence.

Knowledge that the system must enforce belongs outside the model. I keep language work in the model and domain rules somewhere the team can inspect and version them.

References and public artifacts

1. PTSO deployed demo.
2. MJ Hill. The Put That Sh*t On Agent, RenderATL 2026 slide deck.
3. MJ Hill. Models Propose, Contracts Dispose, August 2026.
4. Thomas R. Gruber. A Translation Approach to Portable Ontology Specifications, 1993.
5. Model Context Protocol architecture, official specification.
6. Agent2Agent Protocol documentation, official project site.
7. Agent Development Kit documentation, Google.
8. RenderATL session archive and Commit Your Code session listing.

Evidence boundary

The architecture, failure, timings, and design decisions are documented in the project history, the recovered talk deck, and the published essay. The source repository remains private and is not linked here. PTSO began as an independent project in May 2025; this case study does not present it as RenderATL client work. No private source code, credentials, or internal repository URLs are included.