Poolside Laguna XS.2: Free Local AI Coding Agent for Marketers

Poolside, the American AI startup purpose-built for software agents, launched Laguna XS.2 on April 28, 2026 — a 33-billion-parameter open-weight model released under Apache 2.0 that runs on a single GPU and fits on a MacBook with 36GB of RAM. It hits agentic coding benchmarks competitive with models nearly three times its dense-equivalent size, and it is free to use during the launch period. For marketing technologists, growth engineers, and digital agencies that need a capable, private, locally deployable coding agent without ongoing API costs or data exposure risk, this is a genuinely significant release — not hype, not a research preview, but a model you can pull with Ollama and run against real work today.

What Happened

As VentureBeat reported on April 28, 2026, Poolside released two models simultaneously: Laguna XS.2, its first open-weight release, and Laguna M.1, its most capable model aimed at enterprise use. The XS.2 release is the one that matters for practitioners because it is the rare case of a genuinely strong model being made freely available under a permissive commercial license.

According to Poolside’s technical deep-dive blog post, Laguna XS.2 is a Mixture-of-Experts (MoE) architecture with 33 billion total parameters but only 3 billion activated per token during inference. This distinction is critical for understanding its real-world utility. In practice, the model runs with the compute cost of a 3B dense model while maintaining quality closer to what you would expect from a full 33B model. The model was trained on 30 trillion tokens — the same corpus size as the larger M.1 — and started pre-training just five weeks before its release date, completing full post-training at launch. That development velocity reflects Poolside’s internal “Model Factory” platform: an automated orchestration system handling evaluation, reinforcement learning, architecture experimentation, synthetic data generation, and data mixing across GPU clusters without manual pipeline management.

The architecture is technically distinctive. As documented in the Hugging Face model card, Laguna XS.2 uses 40 total layers with a mixed attention strategy: 30 layers use Sliding Window Attention (SWA) with per-head gating, while 10 layers use global attention. The model has 256 experts with one shared expert, uses FP8 KV cache quantization, and supports a 131,072-token context window with up to 8,000 output tokens. The SWA with per-head gating design was specifically chosen to reduce KV cache memory requirements while preserving inference speed — a configuration optimized for long-horizon agentic coding tasks where context accumulates quickly across hundreds of sequential tool calls.

The training process incorporated approximately 13% synthetic data — around 4.4 trillion synthetic tokens across the full Laguna model series, according to Poolside’s technical blog. The AutoMixer framework simultaneously trains approximately 60 proxy models to measure how changes in data mixture affect performance across capability groups: code, math, STEM, and common sense reasoning. The custom Muon optimizer Poolside developed achieved the same training loss as an AdamW baseline in approximately 15% fewer steps, with overhead optimized to less than 1% of training step time for the larger M.1 model.

The companion Laguna M.1 — 225 billion total parameters with 23 billion activated, trained using 6,144 NVIDIA Hopper GPUs — is available via API, with research institutions able to request weight access. But M.1 is the enterprise offering. XS.2 is the open one.

Poolside is also shipping two products alongside the model weights. The first is pool, a terminal-based coding agent that uses Laguna models locally. The second is Shimmer, a cloud development environment at shimmer.poolside.ai for building web apps, APIs, and CLIs against Laguna models without local infrastructure setup. Model weights are available free on Hugging Face under Apache 2.0, with multiple quantized variants: full FP8, NVFP4 for NVIDIA hardware, and INT4 for maximum compression. API access during the launch period is free via Poolside’s own platform at platform.poolside.ai and via OpenRouter. Ollama with MLX support is live. NVIDIA TensorRT-LLM support shipped on day one.

According to Poolside’s models page, XS.2 is described as “our lightest and fastest agentic coding model” — a positioning that makes its deployment target clear. The company’s Applied Research organization, approximately 60 people spanning infrastructure, architecture, data, pre-training, and reinforcement learning, developed both models in parallel.

Why This Matters

The relevant question for marketing practitioners is not whether Laguna XS.2 is impressive to ML researchers — it clearly is. The question is whether it changes anything about how marketing teams should be architecting their automation stacks and internal tooling. The answer is yes, in three concrete ways.

The cost structure changes. Every team currently running a frontier model API for code generation — whether writing analytics scripts, building campaign automation, generating A/B test variants, or constructing internal dashboards — is paying per token with no ceiling and no ownership of the underlying infrastructure. Apache 2.0 with local deployment eliminates that cost entirely for workloads that can run locally or on rented GPU infrastructure. At 3 billion activated parameters, inference throughput on a local machine is fast enough to be practical for iterative development workflows. Marketing teams running dozens of weekly automation tasks can shift from open-ended API cost exposure to a predictable fixed infrastructure cost that scales with hardware, not with usage volume.

Data privacy becomes genuinely achievable. The marketing data that matters most — first-party customer data, CRM exports, attribution logs, revenue-by-channel breakdowns, customer lifetime value models — is exactly the data that enterprises are reluctant to transmit to external model APIs without legal review and executed data processing agreements. Running Laguna XS.2 locally means proprietary marketing data never leaves company infrastructure. This removes a blocker that has been quietly killing AI-assisted analytics projects at privacy-conscious brands for the past two years. If your legal team has blocked a project because of data residency or transmission concerns, a locally deployed model under Apache 2.0 eliminates that objection cleanly — no DPA negotiation required, no data transfer to audit.

Customization is on the table without vendor lock-in. Apache 2.0 means you can fine-tune this model on your own marketing data — historical campaign performance records, internal brand style documentation, past copy performance data, your specific API integration patterns — and deploy a coding agent tuned to your team’s exact workflows. Closed-access API models offer fine-tuning in limited cases, but the weights are always the vendor’s property. With Laguna XS.2, a fine-tuned version is a company asset that lives in your infrastructure and compounds value over time with your own data.

The timing compounds the significance. As VentureBeat noted, the AI model landscape in early 2026 has been dominated by proprietary frontier models from Anthropic, OpenAI, and Google competing on benchmark leaderboards at escalating API costs. Poolside’s open-weight release is a deliberate wedge into that ecosystem. For marketers who pay attention to where capable open models emerge, this provides genuine leverage in vendor negotiation and stack design decisions.

For agencies specifically, Laguna XS.2 changes the unit economics conversation around AI tooling costs. A boutique agency deploying locally-run coding agents for campaign automation can deliver AI-assisted services at a cost basis that proprietary API providers simply cannot match. The capability gap between XS.2 and frontier models is real but narrow — and for the specific task of generating and executing marketing automation code, a 68.2% SWE-bench Verified score from a locally deployable model under Apache 2.0 is not a compromise position. For the use cases that matter most to marketing teams, it is production-grade.

The 131K token context window also matters more to marketing practitioners than to general software developers. Marketing automation codebases frequently involve connecting multiple APIs with complex documentation — Klaviyo, Shopify, GA4, Meta Marketing API, HubSpot, Segment — and being able to load substantial API reference material directly into context dramatically reduces hallucinated endpoints and incorrect parameter usage. Shorter-context models work around this with retrieval-augmented generation pipelines that add complexity and failure points. XS.2’s native context capacity eliminates that workaround for most marketing tech integration tasks.

The Data

To understand where Laguna XS.2 actually sits competitively, here is the full benchmark comparison from the Hugging Face model card. All results used the Laude Institute’s Harbor Framework with a maximum of 500 steps, temperature 0.7, and top_k 20 sampling, with multiple runs per benchmark (3–7 runs) averaged for each model result.

Source: Poolside / Hugging Face model card, April 2026. Dashes indicate not evaluated on that benchmark.

Several patterns are worth unpacking for practitioners making real deployment decisions.

First, Laguna XS.2 matches Devstral Small 2 on the headline SWE-bench Verified benchmark (68.2% vs. 68.0%) despite Devstral being a dense 24B model. XS.2 achieves equivalent coding quality while activating 87% fewer parameters per inference token. That translates directly to faster output and lower compute cost per query in production — an advantage that compounds significantly across high-volume marketing automation workloads where you are running dozens or hundreds of code generation calls per day.

Second, XS.2 substantially outperforms Gemma 4 31B IT across all four measured benchmarks. Gemma 4 is a capable general-purpose model, but its 52.0% SWE-bench Verified score versus XS.2’s 68.2% reflects the quality difference between a general reasoning model distributing capacity across all domains and a model purpose-trained for agentic software engineering tasks specifically.

Third, XS.2’s multilingual coding benchmark score (62.4%) beats Devstral Small 2 (55.7%) by nearly seven percentage points. For international marketing teams managing multilingual campaign tech stacks, or agencies with clients in non-English markets, this is not a marginal academic difference — it is a meaningful functional advantage in what the model produces when working with non-English codebases, localized API integrations, and multilingual data processing scripts.

Fourth, Laguna M.1 is competitively positioned at the top tier: 72.5% SWE-bench Verified puts it just below Claude Haiku 4.5 (73.3%) and Qwen3.6 (73.4%), but M.1’s 67.3% multilingual score leads the field among the models where that measurement exists. For teams requiring maximum output quality for complex production infrastructure, M.1 is the ceiling and it is a competitive one.

The Devstral comparison is the anchor marketers evaluating this category should focus on. Devstral has been the open coding model reference point throughout early 2026. Laguna XS.2 matching it on primary benchmarks while beating it substantially on multilingual tasks and Terminal-Bench — and doing so with 87% lower compute activation — represents a meaningful shift in what is available to teams constrained by hardware or budget.

Real-World Use Cases

Use Case 1: Marketing Analytics Pipeline Builder

Scenario: A growth marketing team at a mid-size e-commerce brand needs automated Python scripts that pull data from Google Analytics 4, Shopify, and Meta Ads, merge it into a unified performance dashboard, and flag campaigns exceeding CPA thresholds. The team has one part-time data analyst, no dedicated engineering support, and AI API costs have been flagged as a budget concern heading into Q3 planning.

Implementation: Deploy Laguna XS.2 locally via Ollama on a Mac Studio or M-series Mac with 36GB RAM — a hardware configuration that Poolside documents as sufficient for running the model at production quality. Configure the “pool” terminal agent with access to the local codebase and a system prompt defining the team’s preferred data stack (pandas, SQLite, GA4 Data API v1, Meta Marketing API). The agent iterates on scripts within a git repository sandbox, running code against sample data before flagging for human review. No customer revenue data or attribution logs leave the local machine at any point in the workflow.

Expected Outcome: The team generates, tests, and iterates on analytics scripts 3–5x faster than hand-coding them, at a marginal infrastructure cost instead of accumulating API fees. The privacy requirement is satisfied without a legal review process because data does not leave the building. The analyst’s time shifts from writing boilerplate to reviewing and deploying agent-generated output — a substantially higher-leverage use of their capacity.

Use Case 2: Agency A/B Test Tracking Code Generation

Scenario: A performance marketing agency runs A/B tests across landing pages for 12 DTC clients. Each test requires custom JavaScript event tracking, variant logic, and analytics reporting hooks. Engineers currently spend two to three hours per test writing boilerplate tracking code and debugging edge cases. The volume of tests across 12 active clients makes this a significant weekly overhead that is limiting test throughput and reducing competitive differentiation.

Implementation: Deploy a shared internal Laguna XS.2 instance via vLLM on a cloud GPU — a single NVIDIA H100 is sufficient for a team of this size. Integrate it into existing internal tooling via the OpenAI-compatible API endpoint that Poolside provides, so existing tooling connects without modification. Engineers prompt the model with the test hypothesis, target DOM element selectors, and analytics platform (Segment, GA4, or Amplitude), and the model generates a complete tracking script, validates it against a provided DOM snapshot, and outputs inline documentation. Because the weights are owned under Apache 2.0, the agency can fine-tune on its existing historical test code library — producing a proprietary variant that matches the team’s specific naming conventions and platform integration patterns.

Expected Outcome: Per-client engineering time for A/B test tracking implementation drops from two to three hours to under thirty minutes. The agency ships faster test cycles, clients see materially higher testing velocity, and the fine-tuned model becomes a proprietary internal asset that improves incrementally with each engagement. The agency’s cost basis for AI-assisted delivery becomes a competitive differentiator rather than a variable cost passed through to clients.

Use Case 3: Email Automation Workflow Scripting

Scenario: An in-house marketing team at a B2B SaaS company wants to build custom Klaviyo and HubSpot automation scripts: triggers based on product usage events, suppression logic tied to CRM field values, and webhook handlers for edge-case flows the platforms’ native builders cannot accommodate. Their CRM data contains sensitive subscription and billing information that legal has determined cannot be transmitted to third-party AI providers without data processing agreements that are months from execution.

Implementation: Run Laguna XS.2 locally using the Transformers library on a Linux workstation with GPU access. The model handles all code generation on-premises with zero external API calls. The marketing ops engineer prompts the model with the integration schema, desired trigger logic, and relevant API documentation. The model’s 131,072-token context window — documented in the Hugging Face model card — allows substantial portions of the HubSpot or Klaviyo API reference to be loaded directly into context for accurate endpoint generation, without hallucinating non-existent API methods. Hallucinated endpoints are a consistent failure mode with general-purpose models used for integration scripting; native context depth reduces this significantly.

Expected Outcome: Custom automation scripts that previously required a contracted backend developer are drafted internally in hours rather than weeks. All sensitive CRM and billing data stays on-premises, satisfying the legal requirement without waiting for DPA execution. The team ships two to three times more custom automation flows per quarter, increasing campaign sophistication without increasing headcount or external development spend.

Use Case 4: Ad Creative Feed Processing and Dynamic Catalog Management

Scenario: A paid social team at a retail-focused agency manages Meta Dynamic Creative campaigns for eight clients. Each client’s product feed requires processing — variant logic, field normalization, image URL validation, price format standardization — before upload to the Meta Catalog API. Feed processing scripts change weekly as clients update SKUs, pricing, and seasonal category structures. Engineers maintaining these scripts are overallocated, and feed errors are causing campaign launch delays.

Implementation: Integrate Laguna XS.2 via the Poolside API (free during launch at platform.poolside.ai) into a simple internal interface that accepts a product feed schema and Catalog API requirements as input. Use the model’s native tool-calling capability — available via the OpenAI-compatible function-calling interface documented in the Poolside model card — to have the agent generate the transformation script, execute a test run against a sample feed, validate the output structure against the Catalog API schema, and iterate until it passes all validation checks. The agent handles the full loop end-to-end: generate, execute, check, revise.

Expected Outcome: Feed processing scripts are generated, tested, and validated in a single agentic pass without sustained human intervention. Client onboarding for new dynamic ad campaigns drops from a multi-day engineering task to a same-day turnaround. Catalog API errors from malformed feeds — a significant source of campaign launch delays — drop substantially because the agent validates before submission rather than discovering errors after the fact.

Use Case 5: Custom UTM and Server-Side Attribution Infrastructure

Scenario: A media buying team at a large performance agency has outgrown off-the-shelf attribution tools. They need custom UTM parsing logic, cross-domain tracking scripts, server-side event forwarding code connecting ad platforms to a proprietary data warehouse, and session-stitching logic across web and app surfaces. The code is architecturally complex, changes frequently as platform APIs update, and the team cannot justify a dedicated infrastructure engineer at current headcount.

Implementation: Deploy Laguna XS.2 locally with the “pool” terminal agent as described in Poolside’s product documentation. The team describes the attribution architecture — source platforms, data warehouse schema, desired event taxonomy, cross-device identifier strategy — and the agent writes, tests, and iterates on the tracking infrastructure across multiple files. The model’s interleaved native reasoning capability, where it thinks through architectural decisions before generating code, produces more coherent multi-file solutions than direct generation without this reasoning step. The 131K token context window handles large multi-file codebases without losing dependency context across files — a consistent failure mode for models with shorter contexts working on complex tracking architectures with interconnected components.

Expected Outcome: The team maintains a living, agent-assisted tracking codebase that evolves with campaign needs and platform API changes without requiring a dedicated engineer. Engineering overhead for attribution infrastructure drops significantly. The model’s reasoning traces, preserved in the message history per Poolside’s recommended usage patterns, provide automatic documentation of architectural decisions — something marketing engineering teams rarely have time to produce manually.

The Bigger Picture

Poolside’s XS.2 launch reflects a structural pattern that has been building throughout the first quarter of 2026: the gap between open-weight specialized models and proprietary frontier models is closing faster in task-specific domains than in general reasoning. For coding specifically, that gap was always narrower than the general reasoning gap. Coding benchmarks are measurable, reproducible, and high-quality training data is relatively abundant compared to general instruction-following tasks. Specialized models trained almost entirely on code, tool use, and long-horizon agentic task execution reach competitive benchmark performance at smaller scale than general-purpose models that must distribute training compute across dozens of task domains simultaneously.

Poolside’s decision to train on 30 trillion tokens with intensive emphasis on software engineering, tool use, and agentic task execution — backed by the asynchronous on-policy reinforcement learning system described in their technical blog — produced models that outperform much larger general-purpose competitors on the benchmarks that actually predict agentic coding performance in production. The 5-second weight transfer via GPUDirect RDMA between training and inference nodes, and the fully asynchronous RL system, represent genuine infrastructure innovation, not just scaled compute with a better press release.

The MoE architecture decision amplifies the practical impact for marketers. By activating only 3 billion parameters per inference token while holding 33 billion in total, Poolside achieves a compute-to-quality ratio that makes local deployment realistic on hardware that marketing teams actually have access to. Most organizations cannot run a 33B dense model locally with acceptable latency for interactive development work. A 3B-activated MoE model under Apache 2.0 changes that calculation for anyone with a modern Mac Pro, Mac Studio, or a mid-range workstation GPU — a much larger addressable hardware base.

The Apache 2.0 license is the lever that matters most commercially, and it is worth dwelling on. It is the most permissive major open-source license available. It allows commercial use, modification, distribution, and sublicensing without royalty obligations or usage restrictions tied to commercial scale. For agencies building proprietary internal tools or fine-tuned variants on top of the base model, or for brands that want to own a customized model trained on their first-party data, Apache 2.0 removes every legal obstacle that alternatives with more restrictive licenses — Llama-style custom agreements, non-commercial restrictions, attribution requirements that complicate product launches — create.

The companion product launches signal Poolside’s strategic direction clearly. “Pool” and “Shimmer” are not marketing add-ons to the model release — they are the beginning of a developer ecosystem designed to capture the community that discovers XS.2 and convert them into long-term Poolside platform users. This is the same flywheel that made Hugging Face central to the open-model ecosystem and that Mistral has pursued with Le Chat and its API products. Poolside is positioning itself as the default infrastructure for agentic software engineering, starting with the open-weight community flywheel that XS.2 is designed to kick off.

For the marketing technology stack specifically, this matters because the AI tools that marketing teams use are built by developers. The faster the developer ecosystem coalesces around Poolside’s models and tooling — building integrations, publishing fine-tunes, writing tutorials for marketing-adjacent use cases — the faster third-party marketing automation tools and agency delivery frameworks will be built to leverage them. Getting familiar with the model now, before that ecosystem matures, positions practitioners to contribute to and benefit from the ecosystem rather than arriving after the patterns are established.

What Smart Marketers Should Do Now

1. Download and test Laguna XS.2 locally this week via Ollama.

The technical barrier is meaningfully lower than most marketing practitioners assume. If you have a Mac with 36GB RAM, run ollama pull laguna-xs.2 and you are running the model in minutes. Add the “pool” terminal agent on top for the agentic layer. The goal this week is not to rebuild your stack — it is to establish a personal baseline for what the model can and cannot do against your specific tasks. Run it on three recurring work items: a script your team writes repeatedly, an API integration you have been putting off, a data transformation currently done manually in a spreadsheet. Apache 2.0 means zero legal risk in testing, even in a commercial context. The cost is your time and electricity.

2. Audit which current AI API expenditures are code-generation tasks that could migrate to local deployment.

Pull three months of API usage logs from your current providers (OpenAI, Anthropic, or others) and categorize calls by task type: code generation versus content generation versus classification versus analysis. Code generation tasks — writing automation scripts, generating tracking code, building data pipelines, constructing API integrations — are the clearest candidates for migration to a locally deployed open-weight model. For many marketing teams, 20–40% of AI API spend falls into this category when audited honestly. Run those specific workloads through Laguna XS.2 and score output quality before making any cost-reduction commitments. Data beats assumption, and the free launch period gives you ideal conditions to gather that data.

3. Identify one first-party data use case blocked by privacy concerns and scope the path to unblocking it.

If your team has a queued AI project that legal or compliance has stalled because of data transmission concerns, locally deployed Laguna XS.2 may be the specific mechanism that unblocks it. Start by mapping the data involved: what it contains, why it is sensitive, and what infrastructure change would satisfy the privacy requirement. Confirm that local inference with no external API calls meets the requirement. Then scope the infrastructure needed. For most teams, this is a one-to-two week implementation project — not a multi-month initiative. The 131K context window means substantial first-party data loads into context directly, without complex chunking or vector indexing infrastructure that adds failure points and maintenance overhead.

4. Run parallel evaluations of M.1 and XS.2 during the free launch window and document the quality differences.

The M.1 model — 225B parameters, 23B activated, 72.5% SWE-bench Verified — is available free via API during the launch period at platform.poolside.ai. Marketing teams with production-grade requirements for complex infrastructure (custom attribution systems, multi-file automation pipelines, production API integrations with complex business logic) should run parallel evaluations of XS.2 and M.1 on the same representative prompts. Log the quality differences specifically: where does M.1 produce materially better output, and where is XS.2 sufficient for your actual use cases? You need this data before Poolside introduces post-launch pricing, so you can make an informed tier selection rather than defaulting to the cheapest option or over-paying for quality you do not need.

5. Start scoping what a fine-tuning dataset from your existing code library would look like.

Apache 2.0 makes fine-tuning a realistic strategic option, not an academic exercise reserved for large engineering teams. For agencies with several years of client campaign code, integration scripts, and internal tooling, that accumulated codebase represents a meaningful fine-tuning dataset. A model tuned on your specific patterns — your preferred data stack, your naming conventions, your common platform integration approaches, your client-specific configurations — will outperform a general-purpose base model on your actual work in ways that compound over time. The investment is primarily compute time for fine-tuning and engineering time for dataset curation and formatting. The output is a proprietary AI asset. Start by cataloging what code you have, where it lives, and what format it would need to be in for a supervised fine-tuning run. This work is worth doing even if you do not execute on it for another quarter — the scoping clarifies the opportunity.

What to Watch Next

Poolside pricing announcement, Q2 2026: Both Laguna models are free during the launch period. Poolside will introduce pricing post-launch, and the rate structure will determine whether the API-access path remains competitive with local deployment for high-volume use cases. Watch for whether pricing is per-token or flat-rate — flat-rate subscription pricing would favor marketing automation workloads with consistent high usage volumes, while per-token pricing would push more teams toward local deployment for cost control. Monitor pricing announcements at platform.poolside.ai and OpenRouter.

Devstral response from Mistral, Q2–Q3 2026: Devstral Small 2 was the open coding model benchmark to beat heading into this launch. Laguna XS.2 matching it on SWE-bench Verified (68.2% vs. 68.0%) while beating it on multilingual benchmarks (62.4% vs. 55.7%) and Terminal-Bench (30.1% vs. 22.5%) creates competitive pressure for a Devstral update. Watch for a Devstral refresh targeting the multilingual gap and the efficiency differential that MoE architecture creates.

Community fine-tunes on Hugging Face, weeks 2–6 post-launch: The Apache 2.0 release will generate community fine-tunes within weeks of this post. Track the Poolside Hugging Face organization for community model uploads. Watch specifically for marketing-adjacent fine-tunes: models tuned on Shopify scripting patterns, HubSpot or Salesforce API integrations, Google Ads scripts, Klaviyo automation flows. Someone in the community may have already assembled a training set that matches your use case — evaluate those before investing in your own fine-tuning infrastructure from scratch.

Pool agent development roadmap, Q2–Q3 2026: The “pool” terminal agent is Poolside’s answer to what Cursor provides for IDE-based coding. As pool matures over the next two quarters it will likely add capabilities directly relevant to marketing practitioners: better multi-file project context management, integration connectors for common marketing data sources, and potentially GUI elements that lower the barrier for less technically fluent marketers. Watch Poolside’s GitHub and product blog for pool update cadence.

Shimmer cloud environment capabilities, Q2 2026 and beyond: Poolside’s Shimmer product positions Laguna models in a cloud development environment for web apps and APIs without local infrastructure requirements. For marketing teams without local GPU hardware or in-house DevOps capacity, Shimmer may become the lowest-friction entry point to Laguna’s agentic coding capabilities. If Shimmer adds templates or pre-configured environments for common marketing tech integrations — GA4, Shopify, Meta API, HubSpot — it could meaningfully lower the deployment barrier for non-engineering marketing teams who need AI coding assistance but cannot manage local model infrastructure.

Bottom Line

Poolside’s Laguna XS.2 launch on April 28, 2026 is the most consequential open-weight coding model release for marketing practitioners since the original Devstral, and it surpasses that benchmark on the dimensions that matter most for production deployment: competitive benchmark performance at lower compute activation, practical local hardware requirements (36GB RAM), an Apache 2.0 commercial license with no restrictions, a 131K context window for API-heavy integration work, native agentic reasoning with interleaved thinking, and day-one integrations with Ollama, vLLM, and TensorRT-LLM. The combination of matching Devstral Small 2 on SWE-bench Verified while beating it on multilingual benchmarks and Terminal-Bench — all at 3B activated parameters — produces a model that fits on hardware marketing teams already own and runs without ongoing API cost exposure. Teams that evaluate Laguna XS.2 seriously this quarter — testing it against real use cases, auditing their API spend for migration candidates, scoping fine-tuning opportunities with their existing code libraries, and documenting the M.1 vs. XS.2 quality gap during the free launch window — will be materially ahead of the majority of marketing organizations still routing sensitive campaign data through proprietary APIs they do not fully control. The open-weight model wave is not on the horizon. It arrived on April 28, 2026.