Will Open-Weight AI End Up Looking Like Web Hosting?

Question: Will open-weight AI models end up working like open-source web software, where most people are free to run it themselves but pay somebody else to host it?

Probably. The largest open-weight models are already moving beyond the hardware that ordinary developers, small businesses and even fairly serious local-AI enthusiasts can sensibly own. The weights may be downloadable and the licence may allow deployment, modification or commercial use, but most people will still reach the model through a hosting company or API provider. That doesn’t make open weights pointless, although it does mean their practical value will depend increasingly on the infrastructure, portability and competition around them.

A lot of open-source software already works this way. WordPress is open source, but most site owners don’t keep a production server under their desk. Linux is open source, while businesses routinely pay somebody else to maintain the machines that run it. PHP, MySQL and Apache can all be downloaded freely, yet an enormous hosting industry exists because installing software and operating it reliably are different jobs.

Open-weight AI may be heading towards a similar arrangement. You’ll be able to choose a model, inspect the available technical material, download its weights and perhaps move between providers, but unless you’re using a much smaller model, you probably won’t be running it on hardware you own.

The comparison is useful, although it has limits. Moving a WordPress site from one ordinary web host to another is usually inconvenient rather than extraordinary. Moving a trillion-parameter AI model, its serving stack, its customisations and the data around it is a different category of problem.

The model may be open, but your spare room isn’t a data centre

The immediate prompt for this question was the arrival of another enormous open-weight model. Moonshot AI describes Kimi K3 as a 2.8-trillion-parameter mixture-of-experts model, with 104 billion parameters activated for each token. Its architecture avoids using every parameter for every piece of generated text, which makes inference more manageable than running a dense 2.8-trillion-parameter model would be.

That doesn’t make the rest of the weights disappear. The system still needs access to them when the model routes work to different experts, and storing and serving that much model data is an infrastructure problem before you’ve processed a single useful request.

Kimi K3 uses MXFP4 weights. As a deliberately simplified lower-bound calculation, four bits multiplied by 2.8 trillion parameters comes to roughly 1.4 terabytes of raw parameter data. A real deployment also needs room for metadata, scales, activations, context, caches, runtime overhead and the serving software itself, so the practical hardware requirement isn’t captured by that one number.

Now compare that with NVIDIA’s DGX Spark, a machine built specifically for desktop AI development. According to NVIDIA’s hardware documentation, one Spark has 128GB of unified memory and supports models up to 200 billion parameters, while a paired configuration supports models up to 405 billion parameters.

That’s a capable, purpose-built AI computer rather than a gaming PC with an extra graphics card, yet a model such as Kimi K3 still sits well outside its stated range. The model weights can be released publicly, the repository can include deployment instructions, and the licence can allow people to use them, but none of those things put more memory into the machine on your desk.

This isn’t really a complaint about Moonshot AI or about large models in general. Releasing weights at that scale can still be useful to researchers, infrastructure companies, competing model developers and organisations that already operate serious compute. Other teams can study the architecture, build serving systems around it, create quantised or distilled versions, and use the release as a starting point rather than training an equivalent system from scratch.

The release matters, but it doesn’t necessarily mean what an ordinary person assumes when they hear that a model is open.

Open weights don’t automatically mean local AI

There’s already a terminology problem around open AI because several different claims are regularly folded into the same word.

An open-weight release makes the model’s trained parameters available under a particular licence. Depending on those terms, people may be able to download, deploy, fine-tune, study or redistribute the model. That is useful, but it isn’t automatically the same thing as open-source AI.

The Open Source Initiative’s definition goes further by requiring the freedoms to use, study, modify and share the system, along with access to the preferred form for modification. In the case of machine learning, that includes the parameters, the relevant code and sufficiently detailed information about the training data and process.

Even that stronger definition doesn’t answer the practical question of who can afford to run the system. A model can be open under a permissive licence and remain far beyond the hardware budget of nearly everyone who wants to use it.

Legal permission, technical availability and practical accessibility are three different things. A model may satisfy the first two while doing very little for the third.

We already understand this distinction elsewhere in computing. Software can be freely available while its reliable operation requires specialist knowledge, expensive equipment or a team that knows how to maintain it. Nobody expects a small business to run its own global content-delivery network merely because some of the software involved is open source, and nobody claims that Linux has failed because most companies don’t manufacture and operate their own servers.

The same will probably be true of AI. The useful question won’t be whether the files can technically be downloaded, but whether there is a realistic path to run the model, modify it, move it or choose who operates it on your behalf.

Why the web-hosting comparison works

Traditional web hosting works because it separates the application from the physical infrastructure. You can build a site with WordPress, PHP or another open system without owning the server, network connection, backup hardware or data centre. The host supplies those things, while the customer controls the application, content and database to a meaningful degree.

That last part matters. The old web stack isn’t valuable merely because the source code is available; it is valuable because there are plenty of practical places to run it.

A normal PHP and MySQL application can live on a laptop, a small virtual server, a dedicated machine or one of thousands of hosting companies. The exact environment changes, but the application remains recognisable, and moving it elsewhere is usually possible without rebuilding the whole thing around a new supplier.

Open-weight AI is developing a similar split. Model developers release weights at one end, while businesses and builders at the other end want to use those models inside products, internal tools and everyday workflows. Between them sits a growing inference-hosting industry that handles the hardware, model loading, scaling, monitoring and serving software.

Hugging Face already shows what this can look like. Its Inference Providers service presents models from multiple infrastructure companies through a consistent interface, while its managed Inference Endpoints can deploy selected models onto dedicated, autoscaling infrastructure. The developer chooses a model and a provider without personally assembling the hardware needed to serve it.

That starts to sound a lot like hosting. You choose the software, choose the provider, select the capacity you need, pay according to usage or reserved infrastructure, and scale the service when demand changes. The model weights may remain open, while the normal method of using them becomes rented access.

Where the comparison starts to break

There’s an important difference between renting a server for a WordPress site and renting enough infrastructure for a frontier-scale AI model.

Ordinary web hosting is relatively cheap, widely available and technically mature. There are thousands of providers, a small site can run on modest hardware, and moving between hosts is normally achievable even when the process is tedious.

Large-model inference is more concentrated because the provider needs expensive accelerator hardware, large pools of fast memory, high-bandwidth connections between machines, efficient serving software and engineers who understand how to keep the system running without wasting an absurd amount of compute. The biggest models can’t simply be copied onto a replacement virtual server during a quiet afternoon.

That creates several possible kinds of lock-in even when the underlying model has open weights. An application may become tied to a provider’s API behaviour, tool-calling format, caching system, quantised version, fine-tuning service, safety layer or pricing structure. A customer can remain legally free to leave while discovering that moving the actual workload is costly, disruptive and technically messy.

This is where the openness of a model needs to be tested against the reality of its ecosystem. Can another provider run the same weights? Can you export the adapter or fine-tuning work you paid to create? Is the hosted version the official model, or has it been modified and quantised in ways that affect behaviour? Can you reproduce the same application elsewhere, and what happens if the provider removes the model or silently replaces it with a newer version?

Those questions may matter more to a working builder than the presence of a large download button on a model repository.

The host may become more important than the model maker

If this direction continues, the company releasing an open model won’t necessarily be the company most users deal with. Most people will interact with whoever makes the model affordable, fast, reliable and easy to integrate.

That gives inference providers a powerful position in the AI ecosystem. They can compete on price per token, response speed, uptime, privacy, regional hosting, context limits, logging, data retention, fine-tuning, tool support and compatibility with familiar APIs. From the customer’s point of view, the model may become one component of a much larger hosting package.

The pattern is familiar from the web. Plenty of people choose a WordPress host because of its support, backups, speed, control panel or migration service rather than because it runs PHP. The underlying open software matters, but the operational layer is what the customer experiences every day.

AI hosting may settle into the same pattern. A business won’t necessarily care that a particular model contains 2.8 trillion parameters; it will care whether the service answers support questions accurately, processes documents without leaking them, responds quickly enough for customers and fits within a monthly budget.

The benchmark chart attracts attention, while the hosting bill and operational reliability decide whether the application stays online.

Smaller models will still matter

None of this means local AI is finished. It probably means the local and hosted parts of the market will separate more clearly.

Smaller models will continue to improve, and many ordinary tasks don’t require frontier-scale reasoning. A business may not need a trillion-parameter model for document classification, form extraction, internal search, transcription cleanup or a tightly constrained assistant working with a known collection of material.

The best local model won’t always be the most capable model available on a benchmark. It will be the model that performs the job well enough while fitting onto hardware the user can afford, understand and maintain.

Meanwhile, the largest open-weight models may act more like upstream infrastructure. Hosting companies will run the full releases, while other developers create smaller quantisations, distillations and specialised descendants. Many ordinary users will encounter those practical versions rather than the original model.

That isn’t entirely different from other open-source ecosystems. Most developers don’t compile every package from its earliest source or reproduce the full build chain behind their operating system. They use stable distributions, managed packages and versions prepared by people further up the stack.

The important difference is scale. With AI, the gap between possessing the original files and being able to run them can be enormous.

Open still matters when the hardware is rented

It would be easy to look at models this large and decide that open weights are just marketing. I don’t think that’s quite fair.

An open-weight model can still create competition because multiple providers may be able to offer access to it. Researchers can inspect its behaviour, developers can adapt it, smaller versions can be produced, and users aren’t necessarily trapped behind one model maker’s private API.

Those are meaningful advantages, even when an individual builder can’t exercise every option personally. The existence of open weights gives the wider ecosystem choices, and some of those choices eventually reach people who would never run the original model themselves.

The same principle applies to open web software. I don’t need to run a production WordPress site from a computer in my house for WordPress to have value as an open system. What matters is that I can inspect the site, change it, copy it, move its database, replace the host and keep control of the work.

That should be the standard applied to hosted open-weight AI. The question isn’t whether every person can run the largest model ever released on a desktop. A better test is whether people can choose who runs it, move their customisations and data, find another provider offering the same model, understand what has been changed, and fall back to a smaller self-hosted version when independence matters more than maximum capability.

When most of those answers are yes, rented infrastructure can still provide meaningful freedom. When only one or two companies control the practical deployments, the availability of the weight files may not buy ordinary users very much.

What the next 12 months may look like

My guess is that open-weight AI will increasingly settle into three layers.

At the top will be enormous frontier models that only a limited number of organisations can operate properly. Their weights may be available, but using the full models will remain an infrastructure job involving expensive hardware and specialist serving systems.

In the middle will be inference platforms and hosting companies that turn those weights into APIs, managed endpoints and application-ready services. For most builders, this will be the part of the ecosystem they actually use, even when the model underneath is technically open.

At the bottom will be smaller models that run on desktops, workstations, office servers and high-end consumer hardware. They won’t lead every benchmark, but they may be more useful for private, predictable and specialised work where cost, control and reliability matter more than having the most capable model available.

The interesting competition therefore may not be between open and closed models alone. It may also be between open models that require a landlord and smaller models that you can genuinely keep on your own property.

The real test is whether there’s an exit

Open-weight AI probably will end up looking like web hosting because most people won’t operate the biggest models themselves. They’ll rent access from companies that know how to run them efficiently, and that isn’t automatically a failure of openness. Open software has often succeeded precisely because a healthy services industry formed around it.

The question is whether AI develops the portability that made open web software genuinely useful. A WordPress host is a supplier rather than the owner of the site, and the customer can take the files and database elsewhere when the relationship stops working.

An open-model host should work in much the same way. The provider can sell infrastructure, performance, convenience and support, but it shouldn’t become the only practical place where the model, customisation and customer data can exist.

Making the model weights available is a worthwhile start. The more important freedom is having somewhere else to go.