You’re in good company

A few of the companies we’ve worked with.

Loaded by name, run on a guess

Many features on open models start in a notebook. An open model is one whose files are published for others to run, as its license allows. On the Hub, each model lives in a repository with its history: every saved state is a commit, and the model’s page describes it, license included.

In the notebook, the model is loaded by its name, which follows its newest commit. A gated model, one whose author approves each person who asks, is reached with one developer’s own token, the key that reaches the Hub. The hardware is a guess, and nobody has read the license.

Then it ships as it is. The files change when the author updates them. Access rests with one person. An endpoint, a model running for your product alone, stays up all night for a few requests. And legal asks what the license allows.

The notebook did its job: it proved the idea.

A product needs its choices made on purpose: the model and its license, the commit it runs, the place it runs, and access your organization owns.

What we build

Each open model compared, read and pinned, run in the right place and kept up after launch, for one feature or a whole product.

Chosen on your cases
Open candidates compared on your own examples, each with the answer it should give, before one goes further.
Where it runs
Served for you per request, on an endpoint of your own, or on your own servers: chosen by your data, your traffic and your team.
Its page read first
The license, who may download it, its files, any code it brings and its size, checked before a model goes into your product.
Adapted to your task
A small add-on trained on your own examples, on a model left as it is, when tests show instructions alone fall short.
Replies checked before they’re used
A set shape for each reply, enforced where the server supports it and checked by your code everywhere.
Pinned to what you tested
The model’s commit, any code it brings and the libraries that load it, fixed to the versions your tests passed.
Access your organization owns
Copies of the models you use kept under your organization where their licenses allow, and tokens scoped to what each part of the product needs.
Hardware sized to your traffic
The model’s size, its settings and the machine matched to how your product is used, with idle endpoints scaled down.
Running it day to day
Endpoints watched, models moved on your schedule, and the replies people flag reviewed with your team.

Assistants that take actions in your systems?AI Agents
Answers for customers and staff, from your own documents?AI Chatbots & Assistants
Your product inside the assistants people use?MCP & Agent Integration
Models trained on your own data, with their pipelines and monitoring?Data Platforms & MLOps

Read the model’s page before it ships

An open model’s page on the Hub says more than what the model does. It shows what its license allows, who may download it, how its files are stored, whether it brings code of its own, and how big it is. Each one decides whether, and how, the model can go into a product.

So we read it before any code is written: any one of the five can keep a model out, and finding that out after launch costs more.

For each model, we keep a written record of what we read, with the commit we read it at.

An open model’s page

An example

On the page
The license the page states, and any terms its author adds: whether commercial use is allowed, which notices to keep, and what the model may not be used for.
What we do
We read it with your legal team before the model goes further, and write down what your product must do to follow it.

What it allows: commercial use, a notice to keep, limits on use.
On the page
Whether the model is gated. Access goes to a person, never to an organization, and the author can approve each request and block access at any time.
What we do
We request access under an account your organization controls, and give your product a token for that one model.

Gated: the author approves each person who asks.
On the page
Whether the weights are stored as safetensors, which hold numbers alone and load without running code. Files in older formats can run code as they load, and the Hub scans every file pushed to it.
What we do
We load safetensors files where the model offers them, and read the scan on any other file first.

How the weights, the numbers the model learned, are stored.
On the page
Some models bring their own code, which runs on your servers when the model loads, once your code allows it.
What we do
We read that code and pin the commit we read, so the code that runs is the code we read.

Whether it brings code of its own.
On the page
How big its files are and, on some pages, smaller versions of the model with a guide to the hardware each one needs.
What we do
We match the size to the machine your traffic needs, and try a smaller version on your own cases before choosing it.

How big it is, which decides the memory it needs.

Five things on a model’s page decide whether it can go into your product.

A model stays as you tested it

On the Hub, a model is a repository with a history. Loading it by name takes its newest commit, the state its author saved last, and the author can save a new one at any time.

So a product pins the commit its tests passed. The docs show how to load a model at one commit, and ask for it where a model brings its own code, so the code that loads is the code that was read.

Newer versions usually arrive as new models with names of their own, and a model’s page can point to its newer version, so the one you run stays as it is until you move. The libraries that load a model change too, so their versions are pinned with it and moved on the same tests.

A product on an unpinned model gets a next step: the commit it runs today recorded and pinned, then each move tried on its test set first.

Start with one task and the models that could do it

The review covers the models in use, with their licenses, access and commits; where each one runs and what it costs to keep running; the tokens and who holds them; any code a model brings; how its files are stored; the test set, your own examples with the answers you expect, or the cases that could become one; the hardware and settings; the libraries and their versions; where data goes; and where cost can come down.

Then the first changes, in the order we’d make them, starting from a test set.

What you receive is a written review and a proposal for that first step.

Questions worth asking

Can we use any open model in our product?
Only as its license allows. Each model’s page states its license: some limit commercial use or ask for a notice to be kept, and some models are gated, so their authors approve each person who asks. We read each license with your legal team before a model goes further.
Does what we send leave our network?
It depends on where the model runs. On your own servers, no. On an endpoint of your own, it goes to that endpoint, in the cloud and region you choose. Served per request, it goes through Hugging Face to a provider that runs the model: Hugging Face says it doesn’t store what you send or the reply, the provider handles both under its own data policy, and unless you name one, the first available in the order you set is used. We choose the place with your security team, by what your data allows.
Can an open model take over from the one we use now?
Your test set decides. We run the open candidates on the same examples, and compare what matters to the feature: the replies, the speed, and the cost of running it.
What happens when a newer version comes out?
It usually arrives as a new model, and the one you run stays as it is. We run the new one on your test set, and switch when it does better on your cases.
What does it cost to work with you?
It depends on what your features do and where their models run, and on the first step you choose. Before any work starts, you get a written proposal with the scope, the price or rate, and how you pay.
Pricing
Can we hire developers for our own team?
Yes, through a dedicated team: Webair developers who stay with your product over time and work beside your own people.
Dedicated team

Hugging Face is a trademark of Hugging Face, Inc. Webair is independent of Hugging Face, and isn’t sponsored by, endorsed by or affiliated with it.

Let’s build it better

Tell us the task you have in mind and where your data has to stay, and we’ll suggest where to begin, in a short call.

Thanks, we’ll be in touch soon.

Chosen on your cases,run where data allows

You’re in good company

Loaded by name, run on a guess

What we build