A model trained by one team turns up, lightly modified, inside another team’s product three weeks later. A research group publishes weights on a Tuesday and by Friday there are forty fine-tunes built on top of them. A support team writes a prompt that gets copied into a sales workflow, rewritten, and copied again. Almost none of this happens through a contract or a press release.
It happens through what practitioners have started calling the AI exchange, and the phrase is doing more work than most people realise. Sometimes it points to a specific community. Sometimes it means a marketplace where models and agents get bought and sold. Underneath the branding there’s a real system, and it’s worth understanding, because it decides which teams ship quickly and which ones keep rebuilding something that already exists two floors away.
What Actually Changes Hands
Three categories of goods move through the AI exchange, and they behave nothing alike.
Model artifacts. Base weights, LoRA adapters, quantised builds, checkpoints. A fine-tuned adapter for a 7-billion-parameter model frequently weighs under 100 megabytes, which is why it can travel by email, sit in a private repository, or get attached to a chat message without anyone pausing to think about it.
Context. Everything a model reads but never learned: retrieval indexes, embeddings, system prompts, tool schemas, evaluation sets. This is the messy middle layer, usually more valuable than the model itself and far harder to hand over, because it’s welded to a particular schema, a particular vendor, and one person’s sense of what a good answer looks like.
Judgment. Knowing that the summarisation prompt needs a hard token cap, that the retrieval step collapses on documents containing tables, that a specific eval set is contaminated. None of it transfers through a download link.
Most failures in this space come from treating all three as one thing. Shipping weights without context produces a model that looks impressive in a demo and quietly falls apart in production.
The Compression Layer Nobody Notices
Value in the AI exchange concentrates wherever something big gets made small enough to actually run. A frontier-scale teacher model can cost real money per thousand requests. Distil it into a student that fits on a single GPU and the cost curve changes shape. The student is what gets shipped, and increasingly it’s what gets shared.
Getting that cheap enough to run at scale is its own engineering problem, which is why so much effort now goes into making knowledge distillation affordable in production rather than merely possible in a notebook. Once distillation is cheap, the exchange speeds up: smaller artifacts, faster iteration, more people able to participate with ordinary hardware.
The same instinct shows up on the training side. When a distributed run needs every worker to stay in step, passing full parameter sets back and forth is wasteful. Sending only what changed since the last checkpoint is the difference between a pipeline that scales and one that stalls, roughly the idea behind synchronising weight deltas during TRL training runs. Efficiency at the plumbing level is what lets the visible layer of the exchange move at all.
Inside Companies, the Exchange Runs on Guesswork
Very few organisations have anything resembling a marketplace. What they have is a handful of people who figured something out and a much larger group who never heard about it. One analytics team builds a forecast review workflow that saves six hours a week. Two floors away, another team rebuilds it from scratch, slightly worse, over three weeks.
The fix is unglamorous and mostly administrative. Register the workflow. Write down the inputs and the known failure modes. Keep the eval set next to the prompt so whoever inherits it can tell whether it still works after a model upgrade. Teams that do this consistently tend to be the ones that have already worked out what changes when AI becomes the first analyst on a team, because they’ve accepted that output has to be reviewable before anyone trusts it.
The Human Layer Moves Slowest and Matters Most
Skills are the least portable asset in the exchange and the most valuable. A classroom is one of the busiest exchange hubs going, with students passing prompts, shortcuts and half-understood techniques around constantly. Some of that is genuinely useful and some is cargo cult, which is why it pays to look closely at what is actually changing in classrooms and study habits instead of assuming either panic or miracle.
For people already working, the problem is timing. The tools that matter change faster than a degree cycle, so the question of whether an MIT professional education programme justifies its price comes down to something narrow. Does it build judgment, or does it deliver context you could pick up from documentation in a fortnight?
Getting Value Without Burning the Budget
- Start with the smallest artifact that works. A tuned adapter on an open 8B model beats a general-purpose API call for narrow, high-volume tasks more often than people expect.
- Treat eval sets as first-class assets. They’re the only reliable way to tell whether an incoming model, prompt or index is actually better than what you already have.
- Write down failure modes. “Works except on scanned invoices” is worth more to a colleague than a glowing summary.
- Check licences before you ship. Open weights come with terms, and those terms swing wildly between permissive and restrictive.
- Measure the transfer, not the demo. If a workflow can’t be handed to someone else in an afternoon, it hasn’t really entered the exchange.
Where the Exchange Is Being Pulled Next
Two forces are reshaping it right now. The first is evaluation. As more artifacts circulate, provenance and benchmark integrity become the bottleneck, and the teams with trustworthy evals end up setting terms for everyone downstream. The second is agents. Once systems call each other directly, the exchange stops being about humans copying files and starts being about machine-to-machine negotiation over tools, permissions and price.
That shift is already visible in small ways, from tool schemas published alongside APIs to agent frameworks that expect to discover capabilities at runtime. What hasn’t caught up is the paperwork: attribution, liability, and the awkward question of who answers for a distilled model that inherited a flaw from a teacher nobody in the room has access to.
The practical move is unromantic. Keep artifacts small, evals honest, and documentation aimed at the person who inherits your work in six months. The AI exchange rewards that kind of housekeeping far more reliably than it rewards being first to try the newest release.