Redistributed

Some players are actively redistributing AI value outward. Others talk openness while positioning themselves at the center. Here's how to tell the difference.

The most significant redistributor in the AI ecosystem. As Widder et al. (2023) document, the "political economy of open AI" involves complex trade-offs between genuine openness and strategic positioning. Hugging Face navigates this better than most.

Model Hub. Over 500,000 models hosted and served for free. Any researcher, startup, or individual can publish weights and let others download them. This flattens access in a way that didn't exist five years ago.

Transformers library. Wolf et al. (2020) introduced the library that now underpins most practical NLP work. Open-source code that makes it trivial to load and run models. The technical barrier to using AI collapsed partly because of this work.

Datasets. Lhoest et al. (2021) built an open dataset ecosystem — tens of thousands of datasets, openly accessible. Training data was a moat; Hugging Face helped fill it in.

Inference API. Generous free tier lets developers prototype without spending. Paid tiers are competitive. The business model doesn't require locking users in.

Spaces. Free hosting for AI demos. Researchers can share working applications, not just papers.

The cumulative effect: someone with a laptop and curiosity can access capabilities that required a well-funded lab a few years ago. That's redistribution. And it's worth pausing to appreciate what an achievement this is. Hugging Face built a platform that serves hundreds of thousands of researchers and developers, most of them for free. The infrastructure that enables this is expensive, complex, and maintained by a team that has chosen to optimise for access alongside revenue. Credit where it's due.

Ollama & Local Inference

Ollama made it trivial to run open-weight models locally. One command downloads and runs Llama, Mistral, or dozens of other models. No cloud dependency, no API costs, no data leaving your machine.

Why it matters: Local inference means the model runs on your hardware, under your control. Privacy-sensitive applications become possible. Cost becomes predictable (electricity, not tokens). The provider can't cut off access.

The local inference movement builds on Georgi Gerganov's llama.cpp, which proved that large language models could run efficiently on consumer hardware through quantization (Dettmers et al., 2022). This technical breakthrough enabled a wave of tools: Ollama, vLLM, text-generation-webui, LM Studio.

The result is a genuine alternative to the API economy — if you have the hardware.

EleutherAI and LAION

Volunteer research collectives that produced:

GPT-Neo, GPT-J, GPT-NeoX — Early open alternatives to GPT-3, trained transparently (Black et al., 2022)
The Pile — 800GB open training dataset with documented composition (Gao et al., 2020)
LAION-5B — 5.85 billion image-text pairs that enabled Stable Diffusion (Schuhmann et al., 2022)

These projects proved that open, distributed research could produce competitive results. They also demonstrated the model for others: transparent training, documented data, permissive licensing.

Critically, The Pile included a datasheet documenting its composition — following the framework Gebru et al. (2021) proposed for responsible dataset documentation. This set a standard that proprietary labs often don't meet.

Stability AI (complicated)

Released Stable Diffusion openly, which genuinely redistributed image generation capability. Anyone can run it locally; derivative models flourish.

But the company's trajectory shows the tension between VC funding and open development. Investor pressure, commercial pivots, and leadership drama coexisted with open releases. As Widder et al. (2023) argue, corporate "open" releases often serve strategic purposes — commoditizing complements, building ecosystems, or positioning against regulation.

Stability AI is a cautionary tale: VC-backed openness can be real, but it's fragile when business pressures mount.

The Open Standards Battle

MCP (Model Context Protocol)

Anthropic's protocol for connecting AI models to external tools and data sources. The pitch: a standard way for models to interact with databases, files, APIs, and services.

The good: Open specification, permissive license, multiple implementations emerging. If it becomes standard, any model can connect to any tool. That's interoperability — value flows to users, not lock-in.

The tension: Anthropic created it. Anthropic's Claude works best with it. Even open standards have a creator, and creators have interests.

This follows a pattern Cargill (1996) identified decades ago: "embrace, extend, extinguish." Microsoft used it against web standards in the 1990s. The AI version is subtler — you can't extinguish an open protocol, but you can ensure you're always the reference implementation.

The question: Will MCP become truly neutral infrastructure (like HTTP, governed by IETF) or a standard controlled by its originator (like Android, nominally open but Google-shaped)? Too early to tell. Watch whether governance becomes independent.

OpenAI's Function Calling

Not a standard — a proprietary API feature. But it set the pattern that MCP responds to: models that can call external functions, use tools, and interact with the world.

OpenAI hasn't proposed this as an open standard. The capability exists within their walled garden. Others implement compatible versions, but there's no shared specification.

This is the classic platform strategy Srnicek (2017) describes in Platform Capitalism: control the interface, capture the value of everything built on top.

Agent Protocols (emerging)

Multiple efforts to standardize how AI agents communicate:

Agent Protocol (e2b.dev) — Open spec for agent-to-server communication
LangChain/LangGraph — De facto standards through adoption, though framework-specific
AutoGen (Microsoft) — Multi-agent framework with its own conventions
OpenAI Assistants API — Another proprietary interface

The race is on for which approach becomes the standard. As Greenstein (2015) documents in How the Internet Became Commercial, standards battles shape who captures value for decades. HTTP's openness enabled distributed innovation; if AI agent standards are captured by one player, innovation concentrates there.

The Capture Playbook

Companies navigate a delicate balance: appear open enough to attract developers, stay central enough to capture value. Benkler (2006) showed how commons-based production can generate massive value; the question is whether that value gets captured by platforms or distributed to participants.

Open the commodity, own the layer above. Meta releases Llama weights but runs the AI assistant in its apps. Google contributes to open-source AI frameworks but keeps Gemini's best capabilities proprietary. The open piece is marketing; the closed piece is the business.

This isn't new — it's Joel Spolsky's strategy of "commoditizing your complements" (Spolsky, 2002). Make the layers below you free; charge for the layers above.

Set the standard, be the reference. Create an open protocol, become the best implementation. Developers build to your spec; you're always one step ahead. MCP may or may not follow this pattern — watch what happens.

Free tier to paid conversion. Generous free tiers attract builders. When they succeed, they graduate to paid plans. Hugging Face, Replicate, and others use this model. It's not capture per se — but it means the business needs successful paid conversions to survive.

Ecosystem gravity. Release enough open tools that developers build habits around your stack. Switching costs accumulate even without lock-in. This is what Zuboff (2019) calls "behavioral modification" at the infrastructure level — shaping what developers reach for.

Who's Actually Redistributing?

To evaluate any player, ask:

Can I take it and leave? Open weights with permissive licenses pass this test. APIs don't. Standards with single implementations are ambiguous.
Who pays for what? Hugging Face's model relies on paid tiers and enterprise contracts — sustainable if the conversion works. Volunteer projects (EleutherAI) rely on donated compute and labor — fragile but genuinely open. As Eghbal (2020) documents in Working in Public, open source sustainability is harder than it looks.
Where does information flow? Self-hosted models keep your data local. APIs mean your prompts traverse someone else's infrastructure. Zuboff's (2019) framework applies: who has the "means of behavioral modification"?
What happens if they change their mind? Open weights already released stay released. APIs can change terms tomorrow. Standards can fork but forks fragment.

What to Watch

Inference cost curves. Dettmers et al. (2022) showed that quantization could dramatically reduce compute requirements. As this continues, local inference becomes viable for more use cases. That redistributes power away from API providers.

Standard consolidation. Will one agent protocol win? If so, who controls it? HTTP is governed by the IETF, an independent body. The AI equivalent doesn't exist yet. Proposals for AI governance bodies exist (Cihon et al., 2020) but haven't coalesced.

Hardware availability. Nvidia's dominance creates a chokepoint — Khan et al. (2021) document how semiconductor supply chains concentrate power. AMD, Intel, and custom silicon (Groq, Cerebras) are alternatives. Apple Silicon made local inference viable on laptops. More competition means more redistribution.

Policy interventions. The EU AI Act, US executive orders, and other regulations may force transparency that market dynamics don't. The Act's provisions on high-risk systems and general-purpose AI models may require openness that companies wouldn't choose voluntarily (European Commission, 2024).

The Takeaway

Some redistribution is happening — more than in many tech transitions. Hugging Face, open-weight releases, local inference tools, and emerging standards create real alternatives to full platform capture.

But redistribution isn't automatic. It requires ongoing choices: to use open tools when possible, to support projects that redistribute rather than capture, to understand the difference between openness and open-washing.

As Winner (1980) argued, technological arrangements embody political choices. The AI stack being built now will shape redistribution for decades. Who controls it matters.

Sources

Benkler, Yochai. The Wealth of Networks. Yale University Press, 2006. Publisher
Black, Sid et al. "GPT-NeoX-20B: An Open-Source Autoregressive Language Model." arXiv, 2022. arXiv
Cargill, Carl. "Embrace, Extend, and Extinguish." Open Standards and the Digital Economy, 1996.
Cihon, Peter et al. "AI Governance: A Research Agenda." arXiv, 2020. arXiv
Dettmers, Tim et al. "LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale." NeurIPS, 2022. arXiv
Eghbal, Nadia. Working in Public: The Making and Maintenance of Open Source Software. Stripe Press, 2020. Publisher
European Commission. "AI Act." EUR-Lex, 2024. EUR-Lex
Gao, Leo et al. "The Pile: An 800GB Dataset of Diverse Text for Language Modeling." arXiv, 2020. arXiv
Gebru, Timnit et al. "Datasheets for Datasets." Communications of the ACM, 2021. arXiv
Greenstein, Shane. How the Internet Became Commercial. Princeton University Press, 2015. Publisher
Khan, Saif M. et al. "The Semiconductor Supply Chain." CSET, 2021. CSET
Lhoest, Quentin et al. "Datasets: A Community Library for Natural Language Processing." EMNLP, 2021. arXiv
Schuhmann, Christoph et al. "LAION-5B: An Open Large-Scale Dataset for Training Next Generation Image-Text Models." NeurIPS, 2022. arXiv
Spolsky, Joel. "Strategy Letter V." Joel on Software, 2002. Blog
Srnicek, Nick. Platform Capitalism. Polity, 2017. Publisher
Widder, David Gray et al. "Open (For Business): Big Tech, Concentrated Power, and the Political Economy of Open AI." SSRN, 2023. SSRN
Winner, Langdon. "Do Artifacts Have Politics?" Daedalus, 1980. JSTOR
Wolf, Thomas et al. "Transformers: State-of-the-Art Natural Language Processing." EMNLP, 2020. arXiv
Zuboff, Shoshana. The Age of Surveillance Capitalism. PublicAffairs, 2019. Publisher
Anthropic. "Model Context Protocol." 2024. MCP
e2b. "Agent Protocol." Agent Protocol
Hugging Face. "Hub Documentation." HF Docs

General

The Redistribution Stack

The Players Who Redistribute

Hugging Face