Open-Weight LLM · Private & Custom AI
Laguna-XS.2
A 33B MoE coding agent that runs locally on commodity hardware—purpose-built for companies automating technical workflows and building private AI systems that keep code, logs, and operational data on-premises.
Laguna-XS.2 is a 33B-parameter Mixture-of-Experts model with only 3B parameters active per token, optimized for agentic coding, tool use, and reasoning on local machines. It combines sliding-window attention for efficiency with native support for interleaved reasoning and tool calls. For ops teams, this means deploying a self-controlled code-assistant and automation backbone without sending sensitive technical work to third-party APIs.
Model facts
Private deployment
Run Laguna-XS.2 in your own environment
Laguna-XS.2 runs on a Mac with 36 GB RAM or equivalent on-premises infrastructure. Supported in vLLM, SGLang, Transformers, and Ollama; deploy as an OpenAI-compatible endpoint on your own network. No telemetry or external calls required—your code, logs, and intermediate agent reasoning stay entirely in your environment. Hardware requirements scale with batch size and context; FP8 KV-cache quantization reduces per-token memory overhead. Apache 2.0 license permits commercial self-hosting without restrictions.
Operational AI use cases
Internal code review and technical debt remediation
Use Laguna-XS.2 as a code-understanding agent to audit repositories, flag anti-patterns, and propose refactors. Embed it in your CI/CD pipeline to analyze PRs and generate compliance reports—all analysis runs on internal infrastructure, so confidential business logic never leaves the network.
Operational runbook automation and incident triage
Deploy the model as a tool-calling agent that reads system logs, queries internal monitoring APIs, and executes troubleshooting scripts. With interleaved reasoning, it can explain its diagnostic steps to engineering teams, reducing mean-time-to-resolution without outsourcing incident data.
Knowledge base indexing and internal doc Q&A
Use Laguna-XS.2 with RAG to index proprietary engineering docs, architectural decisions, and operational playbooks. Run a private Q&A agent on your intranet so teams retrieve answers without exposing internal documentation to external services.
Custom AI
As a base for custom AI
Laguna-XS.2 is a strong base for fine-tuning domain-specific coding and operational agents. Its MoE architecture and tool-call support enable rapid specialization: add LoRA adapters for your company's codebase conventions, internal APIs, or proprietary troubleshooting flows. The model card documents async off-policy RL training; teams can replicate that for custom agent behaviors. Ideal if you're building a white-label or internal-only AI product that needs to understand code, execute tools, and reason about complex workflows.
In the operating system
Where it fits
In an AI operating system, Laguna-XS.2 occupies the **agent and workflow orchestration layer**. It powers autonomous reasoning tasks (code analysis, diagnostics, documentation retrieval) and sits upstream of your knowledge layer (vector DBs, internal search). Unlike dense LLMs, its low activated parameters reduce latency for multi-step agentic loops, making it suitable for real-time operational automation. Can be chained with task-specific models or routing logic for cost and accuracy optimization.
Data control & security
Self-hosting Laguna-XS.2 on your infrastructure means code snippets, logs, internal documentation, and agent reasoning steps never transit external networks. This is an architectural advantage for HIPAA, SOC 2, or GDPR contexts where data residency is required. The model itself is not intrinsically 'secure'; security depends on your network isolation, access controls, and API endpoint hardening. Audit and patch vLLM / Transformers dependencies regularly. No telemetry in the model; verify your serving infrastructure logs for compliance.
Hardware footprint
**Estimate:** ~66 GB VRAM at FP16 (dense equivalent ~100 GB); ~34 GB at FP8 or 8-bit quantization (common in production). 262k token context window scales linearly with batch size. Sliding-window attention + FP8 KV cache reduce per-token overhead ~40% vs. dense equivalents. For low-latency inference, allocate ≥36 GB on a single GPU (e.g., L40S, H100) or distribute across multiple GPUs. Speculative decoding with the Laguna-XS.2-speculator draft model can reduce wall-clock latency ~30% for coding tasks.
Integration
Laguna-XS.2 ships with vLLM (≥0.21.0) and Transformers (≥5.7.0) support; serve via OpenAI-compatible /v1/chat/completions endpoint. Tool-call and reasoning parsing use poolside_v1 format (custom code required if integrating with non-vLLM stacks). Connect via REST/gRPC to ticketing systems, log aggregators, code repos, and internal APIs. Ollama integration simplifies local deployment on developer machines. For batch jobs (compliance reports, codebase analysis), use Transformers directly with batch inference to amortize startup cost.
When it's not the right fit
- —Your workflow requires sub-100ms latency on single requests (agentic reasoning + tool calls add sequential overhead; batch offline tasks are the sweet spot).
- —You need long-horizon multi-turn conversations with no degradation in reasoning quality (context is large, but MoE models trade some dense-model coherence for efficiency).
- —Your ops team has zero infrastructure—no GPU or high-RAM on-premises resources available; Laguna-XS.2 is optimized for local deployment and cannot run on minimal hardware.
- —Your use case demands the latest frontier reasoning capability (e.g., o1-level math, formal verification); Laguna-XS.2 excels at code and technical workflows but is not a reasoning AGI.
Alternatives to consider
Qwen3.6-35B-A3B
Also a 35B MoE (3B active) with strong coding scores (73.4% on SWE-bench Verified); similar on-device deployment profile. Trade-off: Laguna-XS.2 has better multilingual and agentic tool-call tuning; Qwen may have broader general-knowledge depth.
Devstral-Small-2 (24B dense)
Smaller, fully dense model optimized for coding. Fits on smaller GPUs (~48 GB FP16) and offers lower latency per token. Trade-off: No MoE efficiency gains; higher per-token memory than Laguna-XS.2's activated params; slightly lower SWE-bench scores.
Llama-3.1-70B (or fine-tuned variants)
Larger dense model with wider community tools and integrations. Better for general knowledge tasks and RAG. Trade-off: ~140 GB VRAM at FP16; requires enterprise-grade GPUs; not purpose-built for agentic reasoning or local deployment.
Related open models
FAQ
Can I run Laguna-XS.2 on a single 40GB GPU (e.g., A100)?
Yes. FP8 quantization brings the model to ~34 GB VRAM; you'll have headroom for batch inference or context. At FP16, you'll be tight or need vLLM's paging / tensor parallelism. Benchmark your specific workload on your hardware.
Is Laguna-XS.2 licensed for commercial use in a private deployment?
Yes. Apache 2.0 license explicitly permits commercial use without restrictions. You can deploy privately, modify the model via fine-tuning, and build commercial products. No attribution required, but check your vLLM / Transformers dependencies for their own license obligations.
How do I integrate Laguna-XS.2's tool calls into my internal ticketing system?
Serve via vLLM with `--tool-call-parser poolside_v1` and `--enable-auto-tool-choice`. Parse the response JSON for tool names and args, then call your internal APIs directly. Example: model outputs `{"tool": "query_ticket_db", "args": {...}}`—your wrapper invokes your ticketing REST endpoint and feeds the response back. See vLLM recipes for full sample code.
What's the difference between Laguna-XS.2 and Laguna-M.1?
Laguna-XS.2 is 33B (3B active), optimized for on-device and cost-efficient deployment. Laguna-M.1 is 225B, positioned for higher accuracy and complex multi-hop reasoning. Choose XS.2 for speed and privacy-first ops; choose M.1 if accuracy justifies infrastructure cost and you control on-premises resources.
Build a Private AI Operating System for Your Ops Team
Laguna-XS.2 is built for self-hosted deployment. LLM.co helps you integrate it into a full AI OS—connecting code repos, logs, ticketing, and APIs into a unified automation backbone. Keep your data on-premises, customize the model for your workflows, and scale without third-party APIs. Let's design your ops AI stack.