Postel's Law: Be Liberal in What Your Agent Accepts, Strict in What It Sends

Jon Postel wrote the robustness principle into a 1980 TCP spec, in one sentence: "be conservative in what you do, be liberal in what you accept from others." It was about network packets. It reads like a bug report I could file against half the tool-calling code I've reviewed this year — agents that crash on a response with one extra field, and agents that emit output loose enough that nothing downstream can rely on its shape.

Two failure modes, same missing discipline

The first failure mode is a parser that's too strict on the way in. An LLM emits a tool call with the arguments in a slightly different order, an extra explanatory field it wasn't asked for, a number formatted as a string — none of which changes the actual intent — and a rigid parser throws instead of extracting what it can. The model didn't misbehave in any way that matters; the parser just wasn't liberal enough to tolerate a harmless variation. The second failure mode is the mirror image: a system that's sloppy on the way out, emitting whatever shape was easiest to produce that request — sometimes a string, sometimes a list, sometimes a null instead of an empty array — leaving every downstream consumer to defensively handle three or four shapes for what should have been one contract.

Liberal doesn't mean "accept anything"

The principle gets misquoted as permission to skip validation, and that's backwards — it's permission to validate past the specific formatting details that don't carry meaning, while still rejecting the ones that do. A liberal parser for a tool call should tolerate field order, extra unexpected keys, and reasonable type coercion (a numeric string where an int was expected). It should not tolerate a required field being entirely absent, or a value outside the domain the tool actually accepts — that's not liberal, that's just accepting garbage and hoping the tool downstream fails loudly enough to notice. The skill is knowing which variations are cosmetic and which are substantive, and only being liberal about the former.

Strict doesn't mean "brittle"

Being conservative in what you send means picking one schema and never emitting anything else — not even when it would be more convenient this one time, not even when the caller "probably" wouldn't mind. Every ad hoc exception to your own output contract is a new shape every downstream consumer now has to defend against, and it compounds: three tools each emitting two or three shapes turns into dozens of defensive branches spread across every agent that calls them. A strict sender is not the same as a fragile one. Strictness is a promise about your own output; it says nothing about how gracefully you handle other people's input, which is where the liberal half of the principle does its work.

Where this actually lives in an agent pipeline

In practice, the principle maps onto two separate pieces of code that too many teams merge into one. The liberal half belongs in the layer that parses whatever the model or an external API actually returned — normalize casing, coerce types, fill in defaults, log and continue on cosmetic surprises. The strict half belongs in the layer that constructs what your system sends onward — validate against your own schema before it leaves, and fail loudly if it doesn't match, because a caller downstream is about to trust it unconditionally. Collapsing these into one function is how you end up with a parser that's strict on the way in — because "just validate everything the same way" felt simpler — and sloppy on the way out, because nobody wrote a second check for your own system's promises.

The internet ran on this for a reason

Postel's law held the early internet together across decades of independently built, imperfectly compliant implementations, precisely because it assumed the other side would sometimes be wrong and refused to let that become your outage. An agent pipeline is the same kind of environment — models drift, tool schemas change, upstream services ship bugs — and the systems that stay standing through all of it are the ones that were never depending on everyone else being exactly right, while still refusing to be the thing that's wrong for someone else.