Summary

Eiso Kant personally puts human-level intelligence across most knowledge work 18–36 months away, versus Poolside’s original estimate of 5–10 years, perhaps 15. His thesis is that larger pretrained models alone will not get there: reinforcement learning adds trial-and-error to next-token imitation, and “you don’t fine-tune your way to AGI.” That conviction explains Poolside’s capital-intensive decision to build foundation models from scratch.
Poolside’s core technical asset is reinforcement learning from execution feedback across nearly 1 million containerized repositories and millions or tens of millions of revisions. Tests, compilers, interpreters, and synthetic tests let models explore solutions, execute them, and become “more correct and less wrong.” Code is unusually attractive because its feedback is deterministic yet its problem distribution—from cryptography to database kernels—is broad enough to preserve general intelligence.
Kant treats model development as an optimization problem spanning three scaling axes: parameters, data, and reinforcement learning. Poolside ran more than 4,000 experiments in January across architectures, data mixtures, ablations, and RL sampling, seeking the most intelligence trainable within a fixed time and budget—and serviceable at an economically viable inference price. Coding can support more compute than low-value consumer tasks such as free bedtime-story generation.
The moat is cumulative infrastructure and organizational learning, not one secret algorithm. Poolside’s executable environment grew from 1,000 repositories to 10,000, 100,000, and nearly 1 million, while its training stack, data, hardware mapping, and research team compounded together. Kant similarly credits DeepSeek’s roughly 200 people, $1 billion-plus infrastructure, two years of published work, and 47-page V3 report rather than allegations of stolen data.
Kant says reinforcement learning delivers more usable signal than merely fine-tuning on 100,000 reasoning traces, although supervised traces may help bootstrap training. He rejects claims of broad generalization when traces closely resemble the math benchmarks being improved. The real R1 breakthrough was not the reported “$5 million” headline, but a model developing coherent, human-like reflection and reasoning without being supplied sufficient examples of what that thinking should look like.
Today’s market is still “developer-led, AI-assisted,” with enterprise gains commonly closer to 20–30% than the 10X experienced by some founders and greenfield developers. Poolside’s product has moved from completion to chat and increasingly agentic workflows, with editors, web, and a forthcoming CLI. Over time, Kant expects much of the software-development lifecycle to collapse into models—but not uniformly across ephemeral tools, banking systems, and nuclear-missile software.
Enterprise distribution is part of Poolside’s capability flywheel: revenue finances more compute and talent. Roughly 70% of software-development dollars sit in enterprises, supporting Poolside’s “bring the model to the data” strategy, full-stack private deployment, and first-party AWS relationship. Customers can procure Poolside through Amazon, deploy weights inside their own VPCs, may need separate regulated model instances, and install the stack in under 40 minutes with one IAM role.

Deep dive

1. Poolside began with an AGI thesis, not a coding-assistant feature

Kant started programming young and in 2016 founded Soured, which he describes as the first company focused on AI that could write code. Its models already performed code completion.
He met future Poolside co-founder Jason Warner in 2017, when Warner was GitHub’s CTO and offered to acquire Soured. Kant declined, but “nonetheless, we became really good friends”; they founded Poolside in April 2023.
Poolside’s day-zero plan remains three steps: assist developers, let anyone build software, then generalize into other domains. The broader mission is scalable human-level intelligence that drives goods and services toward zero cost while pulling an “infinite” frontier of scientific and technological progress closer in time.

2. Specialization reallocates finite model capacity without abandoning general intelligence

Kant places Google in the “old guard,” OpenAI and Anthropic in a first AI-company generation, and xAI, Poolside, and Mistral in a second group founded around April–May 2023. He accepts that frontier labs “might all end up even in the same place” on software capability.
Poolside differentiates by distributing its models specifically for software development, not every consumer use case. Yet software is “not about writing code”: it requires world knowledge, multi-step reasoning, long-horizon planning, and the ability to translate reality into digital systems.
A fixed parameter space and real inference cost force trade-offs. Poolside wants broad domain knowledge but willingly sacrifices some comedy, creative bedtime-story writing, and other consumer-oriented behavior to shift more capability toward software.
Kant’s honest non-answer is whether the future belongs to one static, all-powerful model or locally deployed versions that learn from each environment. Today, feeding models enterprise context remains valuable, so private deployment near proprietary data is “a tactical, in-time decision,” not necessarily the permanent form factor.

3. Reinforcement learning is the missing third axis of scaling

Kant’s emphatic framing is, “You will never hear me argue against scale.” What Poolside rejected was the 2023 belief that making the next GPT model 10X larger and adding more web data would alone produce human-level intelligence.
The missing axis was reinforcement learning: next-token prediction resembles imitation, while RL resembles trial-and-error learning. Language can simulate possible reasoning chains, but without external feedback it risks becoming “a snake eating itself” on synthetic data—the chess player who reads textbooks and imagines games but never learns from losing.
This changed Kant’s timeline. At Poolside’s founding he expected human-level intelligence in 5–10 years, perhaps 15; now he personally estimates 18–36 months for “the vast majority of knowledge work.” That is why Poolside built from the ground up: “You don’t fine-tune your way to AGI.”

4. Executable code supplies both deterministic rewards and broad experience

Poolside’s reinforcement-learning environment contains close to 1 million fully containerized repositories with test suites, plus millions or tens of millions of revisions. At a chosen commit, the model can change code and receive feedback from tests, a compiler, an interpreter, or synthetic checks.
The environment spans cryptography, web applications, database kernels, and many other problem types. Models sample candidate reasoning and solutions, execute them, then update toward outcomes that are “more correct and less wrong”—Kant’s preferred formulation over simply right or wrong.
A narrow deterministic task can overfit or collapse a model into a specialist. Coding occupies a useful middle ground: deterministic enough for scalable reward, yet diverse enough that optimizing for it still strengthens language, reasoning, planning, and generalized intelligence rather than producing another system that can only play Go.

5. Every model improvement reduces to better data or better compute efficiency

Kant caveats his account as a “best guesstimate,” given the absence of a grounded scientific theory or robust interpretability. His working model is that neural networks learn high-dimensional representations ranging from factual knowledge to language use, reasoning, and multi-step processes.
Web-scale next-token training disproportionately improved the most represented features—language and knowledge—but not complex reasoning or scientific problem-solving. RL supplies data that can strengthen those scarcer representations; with infinite records of human thoughts and feedback, ordinary next-token prediction might suffice.
His deliberately simplifying rule is that all research either improves training or inference efficiency, or improves data “and hence the intelligence.” Linear attention belongs in the first bucket; scalable reinforcement learning belongs in the second. “Everything you do, you can put in one of those buckets.”
Poolside ran over 4,000 experimental runs in January across architectures, data ablations, weight mixtures, RL, and sample counts. The objective is maximum intelligence within a time and training budget that can still be served affordably—a constraint made easier by economically valuable software work than by free consumer bedtime stories.

6. Enterprise economics forced Poolside to own the entire stack

Poolside calculated that roughly 70% of software-development dollars are spent inside enterprises. Those customers repeatedly asked it to “bring the model to the data, not the data to the model,” leading Poolside to deploy models, context systems, and applications inside VPCs and on-premises environments.
Kant believes “in the fullness of time, everyone will end up on the cloud,” but Global 2000 buyers presently value deployment options other vendors cannot offer. Poolside consequently treats private infrastructure and security engineering as strategic product work, not incidental customization.
Asked why Poolside did not simply add execution-feedback RL atop another company’s model, Kant returned to its AGI objective. Its original “Strong Beliefs Weakly Held in the Face of Empirical Data” included building foundation models from scratch, RL as a capability scaler, and the claim that “all data over time becomes synthetic.”
Kant doubts human-level capability will emerge by post-training the latest open model. He also questions whether “truly open source AGI” will have room to exist if frontier training continues to require enormous capital.

7. Frontier-model moats compound through data, people, systems, and hardware

Kant describes DeepSeek as roughly 200 researchers and engineers with more than $1 billion of infrastructure and two years of strong published work. Its 47-page V3 technical report showed frontier researchers why the model worked; he does not believe it stole data or acted nefariously, while separating that judgment from concerns about CCP-aligned values.
Poolside’s own advantage compounds similarly. Its executable corpus grew from 1,000 repositories to 10,000, 100,000, and nearly 1 million, while data cleaning, distributed training, parallelism, and the team’s shared experience improved month after month.
Hardware determines architecture rather than merely receiving a preselected architecture. Moving from Hopper systems to GB300 configurations with 72 chips connected by NVL changes what is optimal for training and inference; architecture research therefore loops continuously through the underlying silicon.
Scale no longer means parameter count alone. Llama training moved from roughly 2 trillion to 15 trillion tokens—once called overtraining because it was not Chinchilla-optimal—because Chinchilla’s calculation omitted inference economics. Kant contrasts a claimed “632K” interconnected H100/H200-scale system with potentially equivalent FLOPs from 100K GB200s or GB300s: each produces different engineering constraints.

8. Reasoning traces are data, but reinforcement learning carries richer signal

At the limit, Kant says, “all of it is just data.” Infinite high-quality reasoning traces could teach human-level capability through next-token prediction, but under equal compute today, RL outperforms supervised fine-tuning on 100,000 traces because a reward carries more corrective signal than a successful sample alone.
He does not buy claims of “massive generalization” from small reasoning datasets. Often a math benchmark jumps precisely because the fine-tuning traces closely resemble its problems. Enough data might eventually produce broader grokking, and supervised traces can still bootstrap learning, but Kant sees RL as the scalable path.
The striking R1 result was not the “$5 million” training headline. It was that a model could develop coherent thought in language—without being given sufficient examples of what thinking should look like—and then improve on objectively measurable math and coding tasks. The host highlighted observed “wait,” reflection, and reasoning behaviors; Kant emphasized the improvement in self-reflection and useful thought.
The host questioned whether the “zero” work meant AlphaGo Zero, noting that he thought some human seeding remained. Kant’s narrower claim was that the basis is still humanity’s web data, while RL markedly improves thought over the pretrained model and shrinks the solution space that must be searched.

9. Better reasoning narrows a model’s search cone without eliminating creativity

Kant defines current reasoning as objective-oriented exploration. A harder objective still demands richer world knowledge, language manipulation, and sufficient model size; if one correct chain appears among 1,000 diverse samples, the capability is already somewhere in the model’s latent space and training can make it more probable.
His preferred image is a cone of possibilities. Ideally, deterministic tasks succeed at temperature zero and, hopefully, still at 0.7: the model opens enough possibilities to search, then collapses toward the correct answer. A small model’s cone may open widely but lack the capacity to collapse onto a generalizable solution.
The host contrasted a “thin” o3 base that scaled inference compute easily but reached its sigmoid earlier with a “fatter” Sonnet 3.7 that was harder to scale but retained more headroom; reasoning traces also failed to “take root” in a Llama 1 billion model. Kant’s response was compression: squeeze too much knowledge into too little capacity and essential structure is lost.
Creativity is necessary when the route to a deterministic answer is unknown—Einstein needed a wide conceptual cone for relativity—but infinite temperature becomes garbage. RL suppresses whole unproductive branches, such as applying calculus where it does not belong. “It’s a fine line between genius and madness,” for models as for people.

10. Compute budgets should differ for routine work and scientific discovery

For known-budget knowledge work such as accounting or software development, Kant wants the reasoning cone narrow and efficient. For cancer research or materials breakthroughs, he would pay for greater breadth and depth because the useful stepping stone may sit far from today’s accepted path.
He also rejects an infinitely large-model endpoint. Once model size is optimized for available compute and data, it may be better to parallelize models horizontally and search—a return to “the bitter lesson” rather than treating parameter growth as the only source of intelligence.

11. The product moves from assistance toward autonomy as models improve

Poolside wants to expand software creation from perhaps 100 million-plus current builders to anyone being able to build software, while making frontier developers 10X or 100X more productive. Kant sees software as a lever for abundance: stronger intelligence pushes harder on that lever and reduces real-world costs.
Today’s honest formulation is “developer-led, AI-assisted.” Product design must bridge model limitations with the right repository, web, and organizational context; Poolside currently works through editors and the web, with a CLI coming soon.
The form factor is symbiotic with capability: code completion became chat, chat is becoming agentic, and Kant expects increasing autonomy. Better models do not merely produce a higher benchmark score; they change which actions the surrounding product can safely expose.

12. AI joins software teams before it replaces their coordination systems

The host described moving from author to reviewer, producing in one or two months what once took years. Kant treats that as adding an “anthropomorphized intern” or agent to the team: trivial documentation changes need no review, while sweeping refactors still require shared understanding and input.
His contrarian view is that code review exists first for knowledge sharing, with bug detection secondary. As AI generates code faster, teams must still decide which decisions affect enough people or surface area to deserve review; throughput alone does not remove that organizational boundary.
Kant tempers the most dramatic productivity anecdotes: across enterprise environments, current gains are often 20–30%. Unit-test automation might make one developer 2X, 3X, or 4X faster, while another working in a proprietary language may receive little help because the model lacks relevant capability.
More people will build prototypes and internal tools, especially product managers and perhaps the “one in five” businesspeople already trying to rally teams around ideas. But capability does not create universal desire: “not everybody wants to build software, even if they tomorrow can.”

13. The software lifecycle collapses unevenly as reliability rises

For week-long, disposable software, much of the traditional lifecycle may disappear. Nuclear-missile software, global banking, and other systems demanding many nines of reliability would probably retain checks and approvals far longer, even when AI performs each step.
At the theoretical limit, an above-human developer that never introduces a bug could make three-hour CI runs, unit tests, and other gates economically irrational. Kant expects many controls to collapse into models, “but not everywhere and not all at once.”
Today’s workaround for model limits is small, modular software with separation of concerns. A huge monolith built by repeatedly telling a model to “vibe code the hell out of it” eventually collapses—the same lesson Kant learned early in his career when he looked back and asked, “Oh, my God, what monster did I write here in code?”

14. Multi-agent systems may outgrow today’s developer protocols

MCP-like protocols currently help models do what developers do: inspect a database schema, search documentation, or gather information from collaboration tools. In 18 months, Kant is unsure those protocols remain necessary; a computer-use agent might navigate directly, or a model might write code against an API or database.
The harder problem is coordinating perhaps 1,000 model instances. Human organizations use hierarchy because one developer cannot inspect 500 colleagues’ thoughts, but agents can store and retrieve shared reasoning, parallelize file-by-file analysis, and operate across million-token contexts that humans cannot hold.
Kant proposed capturing developers’ generated thought processes as a semantic database of why code exists. The discussion then connected that reusable language reasoning to future agents, interpretability, and possibly safety—even if latent-space reasoning proves more compute-efficient.

15. New architectures matter only when their efficiency survives scale

The host highlighted a diffusion language model that reportedly achieved roughly 10X efficiency with five or six diffusion steps, supported local code editing, and allowed open-ended test-time computation. Kant noted that it was a midsize model with flexible test-time computation; the decisive issue is whether its gains survive scale.
Switching architectures requires checking whether accumulated experiments still hold and demands sufficiently large efficiency gains. Poolside made its own bet on RNN-inspired linear attention more than a year earlier and has run production models with it since the fall, making a diffusion pivot unlikely given other undisclosed architectural work.
Small-model success is not enough. A method demonstrated around 7 billion parameters must retain its advantage at 70 billion and potentially in an MoE configuration. Kant calls the new diffusion model “the tip of the iceberg,” but wants evidence that its gains survive frontier scaling.
Interpretability must also scale. Code remains deterministic and locally inspectable even when no person understands an entire Google-sized repository; neural reasoning may never become fully transparent. Kant favors combining activation- and weight-level work, such as Chris Olah’s team’s research, with language reasoning—while acknowledging that a plausible chain could conceal a different internal objective.

16. Code persists, multimodality expands, and AWS closes the flywheel

Kant has retreated from the strongest Software 2.0 view that everything becomes a model. Payment rails, power grids, and railroad switches benefit from traceable, testable code, while CPUs remain extraordinarily optimized for deterministic execution; a model may therefore write and maintain Uber Eats more cheaply than continuously simulate the entire application as a neural net.
When the host warned of inscrutable systems and cascading failures, Kant noted that human-built infrastructure already has those properties. More capable AI could instead spend large compute budgets hardening legacy systems, writing neglected tests, and improving security: “I want the nurse to be a human, but I want the surgeon one day to be a robot.”
Multimodal capability is “100%” coming where software demands it: screen understanding, computer use, and visual feedback are necessary for beautiful interfaces and console navigation, though APIs remain cheaper for many tasks. Generative UIs are technically plausible, but Kant wants Uber Eats to look familiar each time; people value interface consistency.
Poolside’s first-party AWS relationship turns distribution into research capacity. Enterprises can purchase it under Amazon’s paper, burn down existing commitments, deploy weights inside private VPCs, and use Trainium 1 or Trainium 2. Separate regulated instances may be required, while a managed installation now takes under 40 minutes with one IAM role; solutions architects then help with firewalls, fine-tuning, access boundaries, and adoption metrics.

AI Q&A: Humanoids Will Transform Every Industry w/ Khosla & Adcock Reward Hacking by Reasoning Models & Loss of Control Scenarios w/ Jeffrey Ladish, from FLI Podcast