LLMs auto-alojados en 2026: ¿ha llegado el momento?
The pitch for self-hosted LLMs is compelling: no per-token costs, full data privacy, no rate limits, no vendor dependency. The reality is more nuanced. Self-hosting trades variable API costs for fixed infrastructure costs and engineering overhead.
In 2026, the landscape has shifted enough that self-hosting is viable for a much broader range of applications. Open-weight models have closed much of the quality gap with commercial APIs. Inference engines have matured. GPU availability has improved.
Here is the honest assessment of where self-hosting makes sense, where it does not, and the economics of each option.
The Self-Hosting Landscape in 2026
Open-Weight Models
The top-tier open-weight models in 2026:
| Model | Parameters | Context | Quality (vs GPT-4o) | License |
|---|---|---|---|---|
| Llama 3.1 405B | 405B | 128K | ~95% | Meta (commercial OK) |
| Llama 3.1 70B | 70B | 128K | ~85% | Meta (commercial OK) |
| Llama 3.1 8B | 8B | 128K | ~65% | Meta (commercial OK) |
| Mistral Large 2 | 123B | 128K | ~90% | Apache 2.0 |
| Mixtral 8x22B | 141B (36B active) | 64K | ~80% | Apache 2.0 |
| Qwen 2.5 72B | 72B | 128K | ~87% | Qwen (commercial OK) |
| DeepSeek V3 | 671B (37B active) | 128K | ~92% (MoE) | MIT |
Llama 3.1 70B is the sweet spot for most business applications — it handles support, classification, summarization, and content generation at 85% of GPT-4o quality. For tasks that do not require frontier reasoning, this is sufficient and dramatically cheaper at scale.
Inference Engines
The software that serves models efficiently:
| Engine | Key Feature | GPU Utilization | Ease of Setup |
|---|---|---|---|
| vLLM | PagedAttention, continuous batching | Excellent | Medium |
| TGI (Text Generation Inference) | HuggingFace ecosystem, production-ready | Good | Easy |
| Ollama | Desktop/dev simplicity | Fair | Very Easy |
| TensorRT-LLM | NVIDIA optimization, fastest inference | Best | Hard |
| SGLang | Structured generation, fast constrained outputs | Excellent | Medium |
For production: vLLM or TGI. vLLM has higher throughput; TGI has better tooling and monitoring out of the box. For development and testing: Ollama.
Hardware Requirements
| Model Size | GPU Required | GPU Memory | Monthly Cost (cloud) |
|---|---|---|---|
| 8B (FP16) | 1x A10G | 24 GB | $400–$600 |
| 8B (INT4 quantized) | 1x T4 | 16 GB | $200–$300 |
| 70B (FP16) | 2x A100 80GB | 160 GB | $4,000–$6,000 |
| 70B (INT4 quantized) | 1x A100 80GB | 80 GB | $2,000–$3,000 |
| 405B (FP16) | 8x A100 80GB | 640 GB | $16,000–$24,000 |
| 405B (INT4 quantized) | 2x A100 80GB | 160 GB | $4,000–$6,000 |
Quantization (reducing precision from FP16 to INT4) cuts memory requirements by 4x with 1-3% quality loss. For most business applications, the quality difference is undetectable.
The Economics
Cost Comparison: API vs Self-Hosted
Assumptions: average query = 2,000 input tokens + 500 output tokens.
At 10,000 queries/day (moderate volume):
| Approach | Model | Monthly Cost |
|---|---|---|
| OpenAI API | GPT-4o | $2,250 |
| Anthropic API | Claude Sonnet | $3,150 |
| Self-hosted | Llama 70B on 1x A100 (quantized) | $2,500 + $1,000 engineering |
At this volume, self-hosting is more expensive than API when you factor in engineering time. The API wins.
At 100,000 queries/day (high volume):
| Approach | Model | Monthly Cost |
|---|---|---|
| OpenAI API | GPT-4o | $22,500 |
| Anthropic API | Claude Sonnet | $31,500 |
| Self-hosted | Llama 70B on 2x A100 (quantized) | $5,000 + $2,000 engineering |
At this volume, self-hosting is 3-4x cheaper. The savings justify the operational overhead.
The Crossover Point
Self-hosting becomes cost-effective at approximately 30,000-50,000 queries per day for a 70B model. Below that, API is cheaper when you include engineering costs. Above that, self-hosting savings compound.
For smaller models (8B), the crossover is lower — around 10,000 queries/day — because the hardware requirements are modest.
Hidden Costs
The GPU rental is not the total cost of self-hosting:
| Hidden Cost | Monthly Estimate |
|---|---|
| DevOps engineer time (model updates, scaling, monitoring) | $2,000–$5,000 |
| Monitoring and observability | $100–$300 |
| Load balancer and networking | $50–$200 |
| Model storage and versioning | $50–$100 |
| Backup and disaster recovery | $100–$300 |
| Total hidden costs | $2,300–$5,900 |
Add these to the GPU cost for a true comparison.
Quality vs Cost Tradeoffs
Where Open Models Match Commercial APIs
- Text classification (sentiment, category, intent): Llama 70B achieves 95%+ of GPT-4o accuracy
- Summarization: Comparable quality for straightforward summarization tasks
- Content generation: Good for first drafts, marketing copy, product descriptions
- Translation: Strong for common language pairs (EN→FR, EN→DE, EN→ES)
- fine-tuning-comparison">RAG-based Q&A: When the answer is in the context, retrieval quality matters more than model quality
Where Open Models Fall Short
- Complex reasoning: Multi-step logic problems, mathematical reasoning — frontier models still lead by 10-15%
- Instruction following: Precise adherence to complex output formats — GPT-4o and Claude Sonnet are more reliable
- Nuanced tone: Subtle brand voice, empathy in customer interactions — commercial models handle nuance better
- Long-context tasks: Processing 50K+ token contexts — commercial models degrade less at extreme context lengths
- Safety and alignment: Commercial models have stronger guardrails for regulated use cases
The Hybrid Approach
The optimal architecture uses self-hosted models for high-volume, quality-tolerant tasks and commercial APIs for low-volume, quality-critical tasks:
Query → Complexity Classifier
├→ Simple (70%) → Self-hosted Llama 70B → $0.001/query
└→ Complex (30%) → Claude Sonnet API → $0.015/query
Blended cost: $0.005/query (vs $0.015 all-API)
Savings: 67%
This model routing approach captures most of the self-hosting savings while maintaining quality for difficult queries.
The Operational Burden
Model Updates
Open-weight model releases happen monthly. Each new release may offer better performance, but upgrading requires:
- Downloading the new model weights (70-400 GB)
- Testing against your evaluation suite
- Updating quantization if needed
- Deploying with zero-downtime rollover
- Monitoring for quality regressions
Budget 1-2 days per model update. Skip updates that do not improve your specific use case.
Scaling
Self-hosted inference does not auto-scale like API providers. You need to:
- Monitor GPU utilization and queue depth
- Add instances when utilization exceeds 70% for sustained periods
- Remove instances during low-traffic periods (if using cloud GPUs)
- Handle request queuing during scale-up events
Kubernetes with NVIDIA GPU operator and custom autoscaling rules is the standard approach. Setup takes 2-4 weeks for a production-ready configuration.
Monitoring
Monitor at minimum:
- Throughput: Tokens per second, requests per second
- Latency: Time to first token, total generation time
- GPU utilization: Memory usage, compute utilization
- Queue depth: Requests waiting for processing
- Error rate: OOM errors, timeout errors, generation failures
- Quality: Automated quality scoring on a sample of outputs
FAQ
What is the minimum viable GPU setup for self-hosting? For development and testing: a single T4 (16GB) runs Llama 8B comfortably. Cost: $200/month on cloud. For production: a single A100 80GB runs Llama 70B quantized at 30-50 requests per minute. Cost: $2,000-$3,000/month. Do not try to run 70B models on consumer GPUs — the memory bandwidth is insufficient for acceptable latency.
How much quality do I lose with quantization? INT8 quantization: 0.5-1% quality loss (negligible). INT4 quantization: 1-3% quality loss (acceptable for most applications). INT3 and below: 5-10% quality loss (noticeable, avoid for production). Always evaluate quantized models against your specific test cases — quality loss varies by task.
Can I mix self-hosted and API in the same application? Yes, and you should. Build a provider abstraction that routes to self-hosted for high-volume routes and API for quality-critical routes. This is the most cost-effective architecture for applications with diverse query complexity.
What about model licensing? Llama models: free for commercial use under Meta's license (with terms). Mistral models: Apache 2.0 (fully permissive). Qwen: commercial use allowed. DeepSeek: MIT license. Always read the specific license terms — some models have usage thresholds or reporting requirements for commercial deployment.
Self-hosting is not for everyone, but for the right scale and use case, it is the most cost-effective and privacy-preserving option. We help teams evaluate and implement self-hosted AI infrastructure.