The AI race lately has felt a bit like a game of tennis: first, Anthropic releases a new, pricey state-of-the-art proprietary model for general users (Claude Opus 4.7), then, a week or so later, its rival OpenAI volleys back with one of its own (GPT-5.5). And all the while, Chinese companies like DeepSeek and even Xiaomi are seeking to appeal to users by playing a different game: nearing the frontier, but with open licensing and far lower costs.
So it's a big surprise when a new, affordable, highly performant open source contender from the U.S. emerges. Today, we got one from the smaller, lesser-known U.S. AI startup, Poolside, founded in San Francisco in 2023.
The company launched its two new Laguna large language models, both of which offer affordable intelligence optimized for agentic workflows (AI that does more than just chat or generate content, but can, in this case, write code, use third-party tools, and take actions autonomously), as well as a new coding agent harness called (fittingly) "pool" and a new web-based, mobile optimized agentic coding development and interactive preview environment, "shimmer," which lets you write code with the Laguna models on the go.
The new AI models that Poolside released today include:
Laguna M.1: a proprietary 225-billion parameter Mixture of Experts (MoE) model with 23 billion active parameters. This flagship model is optimized for high-consequence enterprise and government environments, designed to solve complex, long-horizon software engineering problems that require maximum reasoning and planning capabilities.
Laguna XS.2: an Apache 2.0 open licensed 33-billion parameter MoE with 3 billion active. Engineered for efficiency and community innovation, this model is designed for local agentic coding tasks and provides a versatile foundation for developers looking to fine-tune, quantize, or serve powerful agents on a single GPU. In other words, developers can download and run Laguna XS.2 on their desktop or even laptop computers without an internet connection — completely private and secured.
Notably, as mentioned above, only the smaller of the two models, XS.2, is available now under an open source Apache 2.0 license (on Hugging Face) — yet Poolside is offering even the larger M.1 for free temporarily through its API and third-party distribution partners, OpenRouter, Ollama, and Baseten, making it a great use case for developers who wish to test it out.
Also noteworthy: the two new Lagunas were trained from scratch — not fine-tuned/post-trained base models from Chinese giant Alibaba's Qwen series like some other U.S. labs have pursued lately (*cough cough* Cursor *cough).
As Poolside wrote in a blog post today, it's spent the last few years "focused on serving our government and public sector clients with capable models deployable into the highest-security environments," yet is now going open source "to support builders and the wider research community."
When I asked on X why government agencies would seek to use Poolside instead of leading proprietary U.S. labs like Anthropic, OpenAI and Google, Poolside post-training engineer George Grigorev told me in a reply that: "we think that we can be faster to deploy our models to enterprise customers, and we can literally ship weights in fully isolated environments on-prem, so it can work offline. which might be critical for gov/public sectors :) but ofc anthropic enterprise is hard to beat"
Poolside constructs its AI models within a specialized digital environment called the "Model Factory".
At the heart of this process is Titan, the company's powerful internal software that serves as the "furnace" for training. To help the AI learn as efficiently as possible, Poolside uses a unique tool called the Muon optimizer.
Think of Muon as a high-speed tutor; it helps the model master new information approximately 15% faster than standard industry methods, a critical gain when training at the 30-trillion-token scale.
It achieves this by ensuring that every update to the model's "brain" is mathematically balanced and pointing in the right direction, which prevents the AI from getting confused or stuck during its intensive training sessions.
The information used to train these models—a staggering 30 trillion "tokens" or pieces of data—is carefully selected using a system called AutoMixer.
Rather than just feeding the AI everything it finds on the internet, AutoMixer leverages a a "swarm" of sixty proxy models on different data mixes to scientifically determine which combination of code, math, and general web data produces the best reasoning capabilities.
In this way, it acts like a master chef, scientifically testing thousands of different "recipes" to find the perfect balance of computer code, mathematics, and general knowledge.
While much of this data comes from the public web, about 13% of it is "synthetic data". This is high-quality, custom-made practice material created by other AIs to teach the models specific skills that are difficult to find in the real world.
Once the model has finished its basic "schooling," it enters a virtual gym for Reinforcement Learning. In this stage, the AI practices solving real software engineering problems in a safe, isolated digital playground. It learns through trial and error, receiving a "reward" or positive signal every time it successfully fixes a bug or writes a working piece of code. This constant cycle of practice and feedback is what transforms the AI from a simple text generator into a capable "agent" that can plan and execute complex, multi-step projects just like a human software engineer.
While M.1 represents the peak of Poolside’s current research, the smaller Laguna XS.2 may be the more disruptive entry.
At just 33 billion total parameters (3 billion activated), XS.2 is a "second-generation" MoE model that incorporates everything the team learned from training M.1.
Langua M.1's performance on the SWE-bench Pro—a benchmark designed to test an AI’s ability to solve real-world software issues—reached 46.9% on SWE-bench Pro, nearing the performance of the far-larger Qwen-3.5 and DeepSeek V4-Flash.
Poolside Laguna M.1 software tasks benchmark comparison chart. Credit: Poolside
Despite being a fraction of the size, Laguna XS.2 achieves a 44.5% score on SWE-bench Pro, nearly matching its larger sibling.
On the SWE-bench Verified track, M.1 scored 72.5%, outperforming the dense Devstral 2 (72.2%) but trailing Claude Sonnet 4.6, which leads the category at 79.6%.
These results highlight M.1’s specialization in long-horizon software tasks, particularly those involving complex planning across interconnected files.
Poolside Laguna XS.2 benchmark comparison chart. Credit: Poolside
The smaller Laguna XS.2 exhibits remarkable efficiency, nearly matching the performance of its much larger sibling on high-consequence tasks. Despite having only 3B active parameters, XS.2 surpasses Claude Haiku 4.5 (39.5%) and the significantly larger Gemma 4 31B dense model (35.7%) on SWE-bench Pro.
In terminal-based reasoning, XS.2’s 30.1% on Terminal-Bench 2.0 also edges out Haiku 4.5’s 29.8%, although it remains behind specialized "nano" models such as GPT-5.4 Nano, which reached 46.3% on the same benchmark.
Collectively, these benchmarks suggest that Poolside’s focus on agentic RL and synthetic data curation has allowed its smaller models to "punch up" into weight classes typically reserved for far denser architectures.
While top-tier proprietary models like Claude Sonnet 4.6 maintain a lead in overall success rates, the Laguna family—particularly the open-weight XS.2—offers a competitive alternative for developers who prioritize local execution and customizable agent workflows.
All benchmarking was conducted using the Harbor Framework with sandboxed execution, ensuring that the results reflect the models' ability to function in realistic, resource-constrained environments.
To run the Laguna XS.2 (33B) model locally, your hardware must accommodate its 33 billion total parameters. On Apple Silicon, the baseline requirement is 36 GB of unified memory.
For PC and Linux users, while the standard weights would typically require over 60 GB of VRAM, the model’s support for 4-bit quantization (Q4) allows it to run on consumer-grade GPUs with at least 24 GB to 32 GB of VRAM, such as the newly released RTX 5090.
Storage is also a factor; you should reserve at least 70 GB for the full model or roughly 20–35 GB for a compressed version suitable for local "agent" tasks.
For the most seamless experience, Poolside recommends utilizing Ollama or their own terminal-based agent, pool, which are designed to manage the model's native reasoning and tool-calling capabilities on consumer hardware.
You can find the full technical requirements, including specific quantization configurations and code execution sandboxing details, on the official Hugging Face model page and the Poolside release blog. Some sample suggested hardware is listed below:
MacBook Pro (14-inch or 16-inch): You should look for models equipped with the M5 Max chip, which specifically supports a starting configuration of 36 GB of unified memory. While the M5 Pro is available, you would need to custom-configure it to exceed its base memory to meet the 36 GB threshold.
Mac Studio / Mac Mini: A Mac Mini (M4 or M5 Pro) configured with at least 48 GB or 64 GB of RAM is an excellent desktop alternative.
NO "MacBook Neo": this model is not suitable for running Laguna XS.2. Released in early 2026 as a budget-friendly option, the MacBook Neo is capped at 8 GB of non-upgradable memory, which is insufficient for a 33B parameter model.
Single-GPU Setup: The NVIDIA GeForce RTX 5090 is the premier choice for 2026, offering 32 GB of GDDR7 VRAM, which can handle the Laguna XS.2 at high speeds (approximately 45 tokens/sec) using Q4 quantization.
Pro-Grade Setup: For professional developers running complex, long-horizon agents, the RTX PRO 6000 Blackwell (96 GB VRAM) or a dual RTX 5090 configuration allows the model to run without any compression loss.
Minimum PC Spec: An RTX 4090 (24 GB) can run the model with heavier quantization, though performance may be slower during complex reasoning tasks.
Models are only as useful as the environments they inhabit, and Poolside has released two "preview" products to house the Laguna series: pool and shimmer.
pool is a terminal-based coding agent designed for the developer’s local environment. It acts as an Agent Client Protocol (ACP) server, the same harness the team uses internally for reinforcement learning (RL) training.
By bringing the researchers' own tools to the general public, Poolside is effectively inviting the developer community to participate in the "real-world gym" that trains their future models.
Shimmer represents a vision for the cloud-native future of development. It is an instant-on Virtual Machine (VM) sandbox where developers can iterate on web apps, APIs, and CLIs in seconds.
Unlike traditional integrated developer environments (IDEs) such as Microsoft Visual Studio, shimmer integrates the Poolside Agent directly into the workspace, allowing it to push changes to GitHub or import existing repositories with ease.
Perhaps the most surprising feature of shimmer is its portability. Poolside Founding Designer Alasdair Monk shared a demonstration showing shimmer running entirely on a smartphone.
In the demo, a split-screen interface shows the Poolside Agent generating a "Happy New Year 2026!" animation while a dev environment runs below.
As Monk noted, it offers an instant-on VM with Poolside Agent in split screen and a full dev environment on a mobile device.
This suggests a future where high-consequence engineering isn't tethered to a desktop, but can happen wherever an engineer has a screen.
The most significant strategic move in this release is the licensing of Laguna XS.2. Poolside has released the weights of XS.2 under the Apache 2.0 license.
This is a highly permissive license that allows users to use, distribute, and modify the software for any purpose, including commercial use, without royalties. This is a stark contrast to the "closed" models of many competitors or even the more restrictive "open-ish" licenses used by some other labs.
Poolside’s leadership is explicit about why they chose this path. Poolside's blog post states its conviction that "the West needs strong open-weight models" and that releasing the weights is the fastest way for the team to improve their work through community evaluation and fine-tuning.
By putting the weights of a highly capable, 33B-parameter agentic model in the hands of researchers and startups, Poolside is positioning itself as a cornerstone of the open-AI ecosystem.
While Laguna M.1 remains primarily behind an API, the open release of XS.2 ensures that Poolside’s technology will be baked into the next generation of third-party tools.
The core thesis behind Poolside’s work is that software development serves as the ultimate proxy for general intelligence.
Creating software requires long-horizon planning, complex reasoning, and the ability to manipulate abstract systems—all traits central to human cognition. While most current AI "agents" are restricted to tool-calling via pre-defined interfaces, Poolside’s agents are designed to write and execute their own code to solve problems.
This shift from using tools to building systems marks a fundamental evolution in how AI interacts with the digital world.
The team of roughly 60 people in the Applied Research organization spent three years and conducted tens of thousands of experiments to reach this point. Their vision of AGI is not just about intelligence, but about "abundance for humanity".
By focusing on software engineering—a domain with verifiable rewards like test passes and compilation results—they have created a self-improving feedback loop. As the team puts it, they are building a "fusion reactor" for data: extracting every last drop of intelligence from existing human knowledge while using RL to harvest the "wind energy" of new, fresh experiences.
Poolside’s journey is just beginning, but the Laguna release sets a high bar for what "agentic" AI should look like in 2026. By combining frontier-level performance with a commitment to open weights and novel developer surfaces, they are charting a path to AGI that is as much about the way we build as it is about the what we build.
For the enterprise and the individual developer alike, the message is clear: the future of work is agentic, and the language of that future is code.
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。