Private AI · serving and fine-tuning
Your own AI models, trained on your data, running in your infrastructure.
Public AI APIs charge per token and see every prompt you send. WebRobot lets you run open-weight models yourself: serve them to your agents and applications, and fine-tune them on your own documents, conversations and datasets, inside an environment you control. We have validated the full stack on European supercomputer GPU nodes, and we are bringing it to private-cloud deployments.
Validated on EuroHPC GPU nodes (NVIDIA A100), October 2026 · private-cloud (BYOC) integration in development
2,700 tokens/sserved by a 32B model on one node
< 6 minmulti-node fine-tuning test, end to end
97.6 Gb/sInfiniBand between nodes, from our containers
0data leaving your environment
Why run your own models
- No per-token bill. You pay for compute you already control, not for every word your agents read and write.
- Your data stays with you. Prompts, documents and training data never leave your infrastructure.
- A model that speaks your business. Fine-tune on your support tickets, product data, internal knowledge, language or the tools your agents use.
- One platform from data to model. The same WebRobot pipelines that collect and clean your data turn it into a training set, and the models you train power your agents.
What you get
- Private model serving: open-weight models of up to a few tens of billions of parameters (tested with Qwen3 up to 32B) behind Ray Serve and vLLM, with an OpenAI-compatible API for your agents and applications.
- Guided fine-tuning: a wizard where you choose the model, your data and the method — full fine-tuning, LoRA or QLoRA — and see the memory, GPUs and time it needs before you launch.
- Every common data format: raw text for domain adaptation, instructions and question–answer pairs, multi-turn chat including tool use, and preference pairs for alignment. Your WebRobot datasets plug in directly, with source and licence tracked.
- Single-node or multi-node: from one GPU to several nodes connected by InfiniBand, with the platform taking care of the cluster, the network and the clean-up.
- Your models, your storage: trained models and adapters are saved to your own object storage, ready to be served or published.
- The same guarantees as the rest of WebRobot: encrypted runtimes, licence checks at run time, and nothing left behind when a job ends.
Proven: serving models privately
We served two open models with Ray Serve and vLLM inside an ephemeral Kubernetes cluster started by an HPC job, with the GPUs passed to the containers without any special privileges.
Measured on EuroHPC GPU nodes, October 2026| Model | GPUs | Ready after deploy | 1 request | Many requests in parallel |
|---|
| Qwen3-8B | 1× A100 40 GB | 3.5 min | 73 tokens/s | 1,900 tokens/s (32 parallel) |
| Qwen3-32B | 4× A100 40 GB | 5 min | 57 tokens/s | 2,700 tokens/s (64 parallel) |
Times include downloading the model weights. Throughput is aggregate output tokens per second across concurrent requests.
Proven: a supercomputer-class network for training
Training across several machines means exchanging gigabytes between GPUs at every step. We made InfiniBand, the low-latency network of HPC systems, available to our containers at full speed.
Between containers on two different nodes| Measure | Result |
|---|
| RDMA bandwidth | 97.6 Gb/s (full line rate) |
| RDMA latency | 1.5 µs |
| GPU-to-GPU all-reduce over InfiniBand | 9.3 GB/s — about 450× faster than over a standard tunnel |
Proven: fine-tuning across nodes
As a first end-to-end test we fully fine-tuned an open 1.7B model (Qwen3-1.7B) on an open instruction dataset (databricks-dolly-15k), split across two GPU nodes.
Multi-node fine-tuning test| Measure | Result |
|---|
| Training | 200 steps in under 6 minutes, 2 nodes |
| Validation loss | 3.66 → 1.89 on held-out examples |
| GPU memory | 21 GB per GPU out of 40 |
| Output | Model saved in standard Hugging Face format, reloaded and answering |
A validation run, not a quality benchmark. We are now optimising throughput (sequence packing, larger node counts) and adding LoRA and QLoRA.
In development: decision models that drive the browser
Not every step of a web agent needs a large language model. Choosing the next page, recognising how a catalog paginates or spotting a login wall are quick, typed decisions. We are integrating small open decision models that answer them with calibrated probabilities instead of generated text, and that run locally on your infrastructure.
The first one is OneJev (Apache 2.0, from 0.8 billion parameters). The models can then be fine-tuned with the wizard above on navigation traces from your own sources, so that they learn your sites and your domain.
- Real-time agentic navigation: at every step the agent asks the model which element to use, whether the page is done and what kind of page it is. The large model steps in only when confidence is low.
- Auto setup for massive big-data crawls: when a new source is added, the model drives the exploration of the site and the setup of the pipeline, so that it can scale to thousands of sources.
- Directly inside the Spark engine: the model runs in the pipeline next to the browser and is called without network hops, for crawls of millions of pages.
- Sources respected: a login wall, a paywall or a bot challenge stops the run and is reported, never bypassed.
First tests on our Kubernetes cluster, on CPU, against our demo shops: the model picked the right next-page link, pagination type, page type and product link on every page tested. Speed optimisation (quantised models, GPU) and integration into the engines are in progress.
Where it runs
Deployment options| Where | What it is for | Status |
|---|
| Your private cloud (BYOC) | GPU nodes in your cloud account or data centre, operated by WebRobot: private models and fine-tuning next to your data | in development |
| European supercomputers (EuroHPC and national centres) | large training runs and research projects on your own HPC allocation | validated in tests |
Early access
- Available now for pilot projects: private model serving and fine-tuning on your own HPC allocation or GPU infrastructure, set up together with our team.
- Coming next: the fine-tuning wizard in the console, LoRA and QLoRA, the same stack on private-cloud (BYOC) clusters, and local decision models for browser navigation and auto setup in the Spark and agentic engines.
- Ideal first projects: an assistant fine-tuned on your documentation, an agent that knows your tools, a model in your language or domain.
Models, data and tools used in the tests
Put your own AI to work on your data
Tell us what you want your model to know and where your data lives. We will help you pick the model, the method and the infrastructure, and run a first pilot.
