Compression asks. Architecture absorbs.

Look at the interfaces the AI industry has shipped to its users over the last five years. Prompt engineering. Then context engineering. Then tool protocols. Then skill authoring. Each successive layer asks the domain expert to learn more of the system’s language so the system can behave better.

Read fairly, this is a sequence of admissions. The previous interface did not yet absorb enough of the work, so the next one asks for more from the user. A doctor learning to write prompts is not the doctor doing better medicine. A lawyer authoring skills for a model is not the lawyer doing better law. They are the doctor and the lawyer compensating for an architecture that is not yet load-bearing on its own.

The pattern is consistent. When the system cannot absorb a class of work, the user is asked to assemble it instead. Each new interface is presented as progress. It is also the field documenting what the previous interface left unfinished.

The history of useful infrastructure runs in the opposite direction. The web did not require its users to learn HTTP. Cloud computing did not ask application teams to rack servers, wire networks, or manage power. Mobile applications did not require their users to learn binary formats. Email did not ask senders to author their own SMTP envelopes. Each generation of infrastructure absorbed a layer of complexity that previous users had to manage by hand.

When a layer matures, the layer above it becomes simpler to use. The web compounded into platforms; platforms compounded into apps; apps compounded into experiences. At each step, the user interface narrowed and the infrastructure widened. That is what infrastructure means — the work moved underneath, not in front of, the user.

The cascade of interfaces the AI industry has produced inverts that history. Each new layer asks the user, not the system, to do more of the assembly. The substrate is not absorbing complexity; it is exporting it.

The cost of the inversion lands on the people the systems were meant to serve. A radiologist who learns to write better diagnostic prompts is spending hours of expert time training the AI to behave reasonably, not reading more scans. A litigator who authors skills to make a model handle precedent retrieval is doing infrastructure work, not legal work. The expert’s domain expertise is being routed into the system’s preferred input format, when it should be routed into the work itself.

This is not a critique of the model layer. The model layer has produced extraordinary capability and will continue to. It is a critique of where the field has been spending its interface budget. The investment has gone into asking the user to learn the system, when it could have gone into building the architecture that learns the user.

The signal that the architecture is incomplete is that the user is still being asked to assemble the cognition by hand. When the architecture is complete, the prompt is the receipt of work the system did, not the instruction set the user had to draft.

There is an asymmetry between language and architecture that this argument turns on. Language compresses. Architecture compounds. Compression asks. Architecture absorbs.

A model that produces fluent text without an architecture beneath it is producing receipts for cognition that did not happen. The cascade of user-facing interfaces is the field’s tacit acknowledgment of this — each new layer is a partial admission that the previous one did not absorb enough work. The honest response is not to ship another interface that asks for more user-side assembly. It is to build the architecture that absorbs the assembly.

The asymmetry that makes this load-bearing: an interface that asks more of the user does not compound. The user does the work once and then leaves. Knowledge does not transfer to the next user, the next session, the next problem. An architecture that absorbs the user’s expertise compounds. The same expertise, captured once into memory, policy, scope, and audit, is available to every future interaction. Compression amortizes across users; architecture amortizes across time.

V is an autonomous institutions lab. The thesis under V’s work is that the next decade of intelligence work belongs to the architecture beneath the model — identity, memory, context, execution, reflection, and autonomy. The architecture’s job is to absorb what the cascade currently asks of the user.

Agent Residency is V’s open specification for one of the layers the cascade currently leaves to the user — identity, delegation, authorization, and audit for AI agents anchored to responsible legal entities. Agency.AI is V’s commercial implementation of the specification, plus the platform layer above it. Wingman is Agency.AI’s first product — a meta-agent system that builds and governs a team of agent employees, each with verifiable identity, scoped mandate, and audit trail. The build log is part of the proof.

The point of the architecture is not to add another interface for the user to learn. The point is to remove an interface the user should not have had to learn in the first place.