Unlock workflows you could never send to public APIs
Confidential patient records, proprietary trading logic, unreleased chip designs, and defense CAD: run state-of-the-art models on data that can legally never leave your perimeter.
Private LLM deployment · VPC and on-premises
Private LLM deployment inside your own cloud or data center.
We deploy open-weight models you own, base or post-trained, inside your cloud account or on your own servers. Prompts, documents and outputs never touch a third-party API, and you pay for GPUs instead of tokens. A typical engagement takes 4–8 weeks from kickoff to a monitored production endpoint.
Your cloud VPC or on-prem
Zero third-party data egress
You own the weights file
Live in 4–8 weeks
Why g factor
Why own the weights instead of renting an API?
Zero vendor lock-in
You own the weights, the tokenizer, and the serving stack. If you want to switch from AWS to your own servers or run on a local workstation, you have the keys.
Predictable speed and costs
No rate limits, no shared-tenancy latency spikes, and no per-token bill. In our worked example, 45 billion tokens a month costs about $225,000 through a frontier API and $15,000–39,000 on three to six dedicated dual-H100 nodes.
Capabilities
Production LLM serving under your organization’s control.
Qualified model promotion
Deploy an approved artifact and preserve its identity, benchmark evidence, and provenance throughout serving.
- Approved model and adapter revision
- Linked benchmark and provenance records
- Reviewable deployment approval
Customer-controlled serving
Operate specialized model skills inside private cloud or on-premises infrastructure for enterprise applications and agents.
- Controlled endpoint access
- Sensitive data stays within the chosen boundary
- Usage and operational monitoring
Tuned, measured inference
We tune the serving engine for your hardware and traffic and report the throughput and latency we measured. On NVIDIA B300 we took Qwen 3.8 27B from 104 to 9,825 tokens per second.
- vLLM with tensor parallelism, speculative decoding and prefix caching
- FP8 where quality allows
- Portable adapters and checkpoints across targets
How an engagement runs
From kickoff to a production endpoint in 4–8 weeks.
- Week 1
Scope and sizing
Agree on the model, the workload, the quality bar and where it must run, then size the GPUs from your expected token volume.
- Weeks 2–4
Model and quality gate
Choose or post-train the model and test it on your own tasks. It moves forward only with a scorecard you approve.
- Weeks 3–6
Deployment inside your perimeter
Install the serving stack in your cloud account or data center, with access control, rollback to the previous model and usage monitoring.
- Weeks 5–8
Load test and handover
Load-test at your real concurrency, tune throughput and latency, and hand over the weights, configuration and runbooks.
Timelines depend on how much post-training the model needs and on your security review. Pricing is a custom quote after a short scoping call.
Before you start
Common questions
What is private LLM deployment?
It means running your model on hardware that belongs to your company (your AWS/GCP account or on-prem servers). Your prompts, database records, and outputs stay strictly inside your security perimeter.
Who is private LLM deployment for?
Teams whose data cannot go to a public API, such as healthcare, finance, legal, defense and hardware design, and teams whose token volume makes an API bill larger than the cost of dedicated GPUs.
How long does a private LLM deployment take?
Typically 4 to 8 weeks from kickoff to a monitored production endpoint. Serving an existing open model sits at the short end; post-training on your tasks and a long security review move it toward the long end.
How much does private LLM deployment cost?
Each engagement is a custom quote after a scoping call, because model size, token volume and hardware drive the price. Running costs are GPUs rather than tokens: in our worked example, 45 billion tokens a month costs about $225,000 through a frontier API and $15,000–39,000 on three to six dual-H100 nodes.
Which models and GPUs do you support?
Open-weight models such as the Qwen family, as base models or with your LoRA adapters, served with vLLM on modern NVIDIA GPUs. We have published measurements on H100, H200 and B300.
Can I deploy on-premises instead of using a public model API?
Yes. g factor exports standard open-weight formats (LoRA adapters or merged safetensors). You can serve them using high-speed engines like vLLM on any modern NVIDIA GPU setup.
What do we get at handover?
The weights or adapter in standard formats, the serving configuration, the evaluation scorecard the model passed, and a runbook for updates and rollback, so your team can operate the model without us.
What should be checked before a model reaches production?
A production checkpoint should come with a verified test scorecard, a clear rollback button to the prior model, and real-time telemetry monitoring throughput and error rates.
Private beta
Turn your workflow into a skill your model can own.
Bring a model and a task that matters to your company. We'll tell you honestly if post-training fits.
Request Demo