Poolside raised $652 million to build foundation models for software engineering. The company, founded in 2023 by Jason Warner and Eiso Kant, focuses on training models from scratch using reinforcement learning from code execution. This approach targets the economic impact of software development. The investment includes a $500 million Series B from Bain Capital and up to $1 billion from Nvidia. The company has a reported valuation of approximately $12 billion.
The Laguna model family
Poolside provides the Laguna family of models for different coding needs. The Laguna M.1 is a proprietary mixture-of-experts model with 225 billion total parameters and 23 billion active parameters. It is designed for high-consequence enterprise and government environments. The model is optimized for long-horizon software engineering problems that require reasoning and planning. The Laguna XS.2 is an Apache 2.0 licensed mixture-of-experts model with 33 billion total parameters and 3 billion active parameters. This model is designed for local agentic coding tasks. It provides a foundation for developers who want to fine-tune or serve agents on a single GPU.
| Feature | Laguna M.1 | Laguna XS.2 |
|---|---|---|
| Model Type | Proprietary MoE | Apache 2.0 MoE |
| Total Parameters | 225 billion | 33 billion |
| Active Parameters | 23 billion | 3 billion |
| SWE-bench Pro Score | 46.9% | 44.5% |
| SWE-bench Verified | 72.5% | N/A |
| Terminal-Bench 2.0 | N/A | 30.1% |
The Laguna M.1 performance on the SWE-bench Pro benchmark reached 46.9%. This score approaches the performance of the Qwen-3.5 and DeepSeek V4-Flash models. On the SWE-bench Verified track, the Laguna M.1 scored 72.5%. This result exceeds the 72.2% score of the dense Devstral 2 model. The Laguna XS.2 also performs well. It achieves a 44.5% score on the SWE-bench Pro benchmark. This score is higher than the 39.5% score of Claude Haiku 4.5 and the 35.7% score of the Gemma 4 31B dense model. In terminal-based reasoning, the Laguna XS.2 scored 30.1% on Terminal-Bench 2.0. This result is higher than the 29.8% score of Haiku 4.5 but lower than the 46.3% score of GPT-5.4 Nano.
Training through the Model Factory
Poolside builds its models in a digital environment called the Model Factory. The internal software Titan acts as the furnace for training. The Muon optimizer helps the model master information 15% faster than standard industry methods. This optimizer ensures every update to the model brain is mathematically balanced. This prevents the AI from getting confused during training sessions. To select information, the AutoMixer system uses a swarm of sixty proxy models to test data mixes. This selection process uses 30 trillion tokens of data. About 13% of this data is synthetic data created by other AIs. After training, the models enter a virtual gym for reinforcement learning. The AI practices solving software engineering problems in an isolated playground. The model receives a reward when it successfully fixes a bug or writes working code.
The company uses Reinforcement Learning from Code Execution Feedback to improve reasoning. The models explore solutions for millions of tasks across 130,000 real world code bases. The models receive execution feedback for every solution they attempt. This scaling of feedback is intended to help models reach human level capabilities in software development. The recent capital raise allowed the company to scale its training cluster to 10,000 GPUs. This scale supports the expansion of both the reinforcement learning process and model training.
Testing Laguna with Explorbot
I tested the Laguna models using Explorbot, an open-source QA agent. Explorbot uses three model slots to perform automated exploratory testing on web applications. The model slot reads pages using cleaned HTML and an ARIA tree. The agentic model slot decides the test plan and supervises execution. The vision model slot reads screenshots for visual checks. I compared the Laguna models against the gpt-oss-20b model served by Groq.
The Laguna-xs model completed a full session end to end on its own. It planned the suite, drove the browser, signed in, and asserted the result. It finished two scenarios in five and a half minutes. The Laguna-xs model identified a testability problem when the sign-in submit button could not receive a click through any standard locator. The model failed three separate click strategies and fell back to clicking coordinates to bypass the issue. The Laguna-xs model reads pages reliably, calls tools correctly, and runs a full session end to end on its own. The Laguna-xs model provides the necessary reasoning for local agentic tasks and works well for reading pages, but the larger Laguna-s model failed to follow the JSON schema requirements and spent eight minutes hitting request timeouts during the testing process.
The Laguna-s model failed the planning task. It produced twenty-one replies to the planning task, and none of them contained valid JSON. The Laguna-s model also struggled in the reading slot. It spent eight minutes hitting request timeouts in the Explorbot request. The Laguna-xs model was cheaper per token than Groq, but it required more calls and more input to finish the same work. Each call with Laguna-xs also took three times longer to return than a call with Groq.
Enterprise and government deployment
Poolside targets high-security environments for its software. The company markets full model weights for on-premises and air-gapped government deployments. This allows government agencies to work offline. They do not charge per-token fees for these on-premises runs once the contract is signed. Early customers pressure-test the product in enterprises with high standards for privacy and security. These enterprises employ thousands of developers and manage complex data environments.
The company pursues two parallel races. The first is the capabilities race, which focuses on building advantages in talent, compute, research, and data. The second is the go-to-market race, which focuses on building advantages in talent, product, and distribution. The capital raise supports both goals. Poolside provides the poolCLI agent for terminal-based coding workflows and shimmer, which is a web-based, mobile optimized agentic coding development environment. The shimmer environment lets users write code with the Laguna models while on the go.
Pricing and API access
Poolside provides its own endpoint for free for a limited time. No end date for this offer is published. The API documentation sits behind an access code. OpenRouter also provides access to the models. At OpenRouter, laguna-xs costs $0.06 per million input tokens and $0.12 per million output tokens.
| Provider | Model | Input Price (per 1M tokens) | Output Price (per 1M tokens) |
|---|---|---|---|
| OpenRouter | Laguna-xs | $0.06 | $0.12 |
| Poolside | Laguna-M.1 | Free (limited time) | Free (limited time) |
The Laguna-xs model is cheaper than Groq on both input and output sides when using OpenRouter. The free endpoint from Poolside allows developers to test the models without paying per-token fees. You should check the hardware requirements before committing to a local deployment. Will the free endpoint period last long enough to satisfy the developer community?
Hardware requirements for local use
Users running the Laguna XS.2 model locally must account for parameter size. The model requires at least 33 billion total parameters. Apple Silicon users require 36 GB of unified memory on a MacBook Pro with an M5 Max chip. For these users, a MacBook Pro with an M5 Pro would require custom configuration to exceed its base memory and reach the 36 GB threshold. A Mac Mini with an M4 or M5 Pro configured with at least 48 GB or 64 GB of RAM is an appropriate desktop option.
PC and Linux users can use the 4-bit quantized version of the model with 24 GB to 32 GB of VRAM. This version is suitable for consumer-grade GPUs like the RTX 5090. If users want to run the standard weights without quantization, they need more than 60 GB of VRAM. Storage requirements depend on the version of the model being used. Users should reserve at least 70 GB for the full model. They can reserve 20 GB to 35 GB for a compressed version intended for local agent tasks.
Comparison with Knowlee and Eigent
Knowlee and Poolside operate at different layers of the agentic stack. Knowlee is an agentic operating system for business functions like sales, legal, talent, and content. It uses a jobs registry and a knowledge graph to manage a fleet of agents. Poolside provides the coding-domain foundation models and the poolCLI agent. A coding agent from Poolside can run as one role inside a Knowlee job. Knowlee handles the scheduling, auditing, and cross-vertical intelligence.
Eigent is an open multi-agent application that is Apache-2.0 licensed. Eigent allows teams to own the application layer and switch between different models. This differs from Poolside, which provides the models and the enterprise deployment. An Eigent stack is a good choice if an organization already has a suitable model endpoint and wants to move between models. Poolside is the better choice when a buyer needs contracted full-weight delivery and enterprise hardware integration.
Poolside is the stronger choice when the buyer requires contracted full-weight delivery, air-gapped government support, enterprise hardware integration, and vendor accountability. An Eigent stack is the better choice when the organization wants to own the application source and needs a model that is portable across different providers.
