Poolside’s Model Factory, Laguna S, Open Models, and the Race to AGI — Eiso Kant, Poolside AI

This Recap covers Latent Space’s YouTube interview with Eiso Kant, co-founder of Poolside, an AI lab building models for long, complex coding work; a Baseten interview and Poolside’s own releases add supporting detail. The company recently launched Laguna S 2.1, a coding model released with open weights and designed to reason through difficult tasks over many steps. In the interview, Kant explains the Model Factory—the data, training, evaluation, and engineering system behind Poolside’s models—and Poolside’s philosophy of model building, shaped by years of doing the work. His argument is that open research should share how the factory works and why it was built that way, not just the finished weights and benchmarks.

Kant traces Poolside back to Sourced, his earlier open-source code-model company. After that company failed, ChatGPT’s release renewed his belief that increasingly capable AI should be open.

• Sourced spent $12 million and kept about 40 people focused on code models for several years.
• Kant stepped away from language models for two years before ChatGPT’s release brought him back.
• He says Poolside made openness part of its mission while the company was still small.
• Kant says that choice would have become harder after the company accumulated more capital and expectations.

Downloadable weights let people modify a model but do not show how to recreate it, Kant says. Research reports can expose the experiments, data choices, and engineering lessons behind the weights.

• Poolside built its first training codebase without forking another open-source system.
• Model releases now take weeks instead of the three years required for Poolside’s first model, according to Kant.
• Poolside’s supporting release says its weights can be fine-tuned, quantized, and served.
• Funding expensive training while giving weights away remains an unresolved business problem.

Poolside’s Model Factory turns research ideas into traceable experiments and results. Researchers spend much of their time inspecting data and writing code, which is why Kant calls model building 90% engineering.

• The process covers data preparation, distributed training, post-training, reinforcement learning, and evaluation.
• Poolside represents experiments as code and can trace data back to its source and code version.
• Its reinforcement-learning system evaluates checkpoints on sandboxed coding tasks while training continues in parallel.

Laguna S solves difficult tasks by checking its work, backtracking, and trying again, Kant says. Poolside’s supporting releases give its architecture, benchmarks, limits, and early usage figures.

• Laguna S has 118 billion total parameters but activates 8 billion for each token.
• That persistence helps with mathematics, programming, research, and documentation checks.
• Poolside also says the model can think for too long without progress and needs better effort controls.
• OpenRouter traffic was approaching 250 billion tokens that day, Poolside reported, without claiming unique users or revenue.

Model development should become one continuous curriculum instead of several separate training phases, Kant argues. Current compute and organisational limits still force Poolside to use simpler stages.

• Earlier reasoning training could extract more knowledge from web data than next-token prediction alone.
• Cheaper models and newer hardware should make training more continuous, Kant expects.
• Current training combines supervised fine-tuning with reinforcement learning on tasks the model cannot yet solve reliably.

Coding teaches capabilities that transfer to other knowledge work, Kant says. A virtual machine with binaries, a codebase, files, and memory lets the agent build complex actions.

• Code lets a model combine loops, conditions, files, and memory into longer actions.
• Laguna S performed useful deep research despite not being trained specifically for it, according to Kant.
• In Poolside’s supporting test, the model improved an agent harness by 5.2% and cut memory allocation by about 70%.

With limited researchers and compute, Poolside is prioritising language reasoning and longer tasks. The company has started vision work but does not plan to work on audio soon.

• Audio may become necessary closer to AGI, but Kant does not see it as a current route toward AGI.
• Vision could improve general capability while also producing useful features now.
• Different foundation-model companies can follow different paths; Poolside is concentrating on its own.

The visible training run is small beside the research, data, infrastructure, and preparation behind it, Kant says. A headline training price therefore captures only part of a model’s cost.

• The new model’s pre-training run was planned for 39 days.
• DeepSeek showed that a capable model’s final training run need not be extremely expensive, Kant argues.
• From training start to publication, Laguna S 2.1 took under nine weeks, Poolside reports.
• A complete Poolside cycle includes pre-training, post-training, and release preparation.

Rules should not permanently concentrate model building among a few companies, Kant argues. When evaluators identify a capability people can misuse, he says Poolside may need to restrict it or release a different model version.

• Unilateral decisions by one company create a dangerous concentration of power.
• International limits on particular capabilities would be better than blanket rules about model availability, in Kant’s view.
• Broad barriers could entrench incumbents, and Kant acknowledges Poolside’s interest in opposing them.

Reinforcement-learning throughput and hardware design determine how quickly Poolside can improve its models, Kant says. The main constraint is elapsed training time rather than the total number of GPUs.

• Reinforcement learning has fewer distinct tasks than web-scale pre-training, which limits useful batch sizes.
• Lower-precision reinforcement learning on newer Nvidia hardware is one option Poolside is exploring.
• Frequent smaller training runs let the team test Model Factory improvements and identify what changed.