The Context Problem
What does the shipping container reveal about context? How standardisation can both solve and obscure the need for contextual understanding.
The Core Argument
The container solves the context problem for physical goods — but it also creates a new context problem by hiding what is inside.
The shipping container is a solution to a context problem. Before the container, every transfer point required context — knowledge of what was being moved, how to handle it, where it was going.
The container solved this by standardising the packaging. You no longer needed to know what was inside to move it. The container handled the context.
But the container also created a new context problem. Once the container is sealed, the contents become invisible. You can move it, but you cannot see what is inside. You have to trust the declaration.
This is the container's lesson about context: standardisation solves some context problems but creates others.
The Container as Context Solution
How the container reduced the need for contextual knowledge.
Before the container, every item required contextual knowledge:
- What is it?
- How heavy is it?
- Is it fragile?
- How should it be handled?
- Where is it going?
This knowledge had to be transferred at every handoff. It was friction — and it was a source of error, delay, and cost.
The container solved this by abstracting away the contents. The container is just a box. You do not need to know what is inside to move it. You just need to know its weight, size, and destination.
Key insight:
Standardisation reduces the need for context. When everyone uses the same container, you don't need to know what's inside to handle it. This is the power of standardisation — it makes context transferable.
The Container as Context Problem
How the container created a new kind of contextual uncertainty.
Once the container is sealed, the contents are hidden. This creates new problems:
What's inside?
The container hides its contents. You have to trust the declaration. This is a context problem — you cannot inspect what is inside without opening the container.
Is it safe?
The container can conceal dangerous goods, smuggled items, or contraband. Security becomes a context problem — you cannot see the risk.
Is it as declared?
The container can be misdeclared. This is a trust problem — and a context problem. You cannot verify without additional information.
Who is responsible?
When something goes wrong, who is accountable? The shipper? The carrier? The receiver? The container makes accountability more complex.
The Acacia perspective:
The container reveals a fundamental tension: standardisation reduces the need for context, but it also creates new context problems. In the Judgment Economy, the same tension exists. Standards reduce the need for context — but they also create new risks of misrepresentation, hidden risk, and accountability failure.
The Context Problem in the Judgment Economy
What the container teaches us about context in the age of abundant intelligence.
The container's context problem is a metaphor for the Judgment Economy's context problem.
In the Judgment Economy, value is packaged in containers too — context, standards, protocols, credentials. These containers make value transferable.
But they also hide what is inside.
Context is the container for intelligence
Without context, intelligence is just data. Context tells you what situation the intelligence applies to, what constraints exist, and what history matters.
Standards are containers for judgment
Standards define what good judgment looks like. They make judgment transferable — but they also hide the specific reasoning behind a judgment.
Credentials are containers for trust
Credentials signal trustworthiness — but they hide the actual evidence of competence. You have to trust the credential.
The risk of misrepresentation
Just as a container can be misdeclared, a credential can be falsified, a standard can be gamed, and context can be manipulated. The container teaches us to design for this risk.
The container teaches us that every standardisation creates a context problem. We must design for both — the solution and the problem it creates.
Reading path: