AGI: The Path Forward

What would it take to close the gap between language models and human intelligence? Poolside’s starting conviction is that next-token prediction needs to be paired with reinforcement learning. Jason Warner describes two and a half years of building models from scratch around that idea. Malibu Agent, the second generation, provides the model behind the demonstration that follows.

The concrete starting point is an Ada database. Warner connects the language to critical infrastructure and satellites, although the demonstration does not identify this database as an operational satellite system. Before changing anything, Eiso Kant asks the assistant what the codebase does. Inside Visual Studio Code, the assistant inspects the project and produces a structured overview. Understanding the existing program precedes the migration request.

Warner knows other languages better than Ada, so the next request is straightforward: convert the database to Rust. The interface resembles other coding agents, but Warner emphasizes that Poolside supplies its own model rather than using OpenAI or Anthropic. He places the work in the context of Poolside’s preceding year serving government and defense organizations, where mistakes and access decisions can have serious consequences.

As the conversion proceeds, a middle pane streams the changes. This makes the agent’s work visible while it is happening, rather than presenting only a final answer. Visibility accompanies a separate requirement: the agent must operate within appropriate permissions. In sensitive environments, access to a data source cannot mean permission to do anything with it. Warner argues for tightly constrained operation; he does not describe a complete permission-enforcement architecture.

Kant reports approximately 1,152 generated lines for this conversion. A command appears to start testing the result, and the live diff view exposes the files the agent has created. These are intermediate artifacts: the conversion has produced code and reached a point where execution can begin.

Kant describes inference as fast, without supplying a throughput measurement, and later reports ten completed tasks. Warner immediately asks whether the result works. The agent has written build commands, and Kant inspects their output, which looks promising. A completed task counter and reassuring output are useful signals, but the next step is to run the application itself.

The agent’s summary is not the end of verification. Kant asks how to run the program, receives instructions for both the Ada and Rust versions, and launches Rust. Output briefly looks like a demo bug, but turns out to be warnings. Warner’s question about a possible unwrap is a joke and a question, not the identification of a confirmed defect.

The Rust program opens a REPL, an interactive loop that accepts commands and displays results. Kant checks a small but meaningful path through the database:

1. Run Help to discover the available commands.
2. Create a users table.
3. Insert a record.
4. Execute SELECT * FROM users and inspect the returned record.

The record appears. This smoke test establishes that the demonstrated create, insert, and retrieve sequence works in the Rust program; it does not establish complete behavioral equivalence with the Ada implementation.

Using the database reveals the next requirement: pressing the up arrow does not recall earlier commands. Kant asks the agent to add that behavior. This is a narrower task than the language conversion, with an observable acceptance condition: after entering a command, the user should be able to retrieve it with the up arrow.

The agent identifies a package, and Kant compares the edits with the earlier version. It adds RustyLine, a Rust line-editing library, and changes the relevant files. The mechanism is to let a line editor handle keyboard input and maintain command history instead of treating terminal input as plain lines.

A minimal Rust example shows the integration point: read a command, add it to history, then dispatch it. Entering help records that command so the next prompt can recall it. This example uses the current RustyLine 18 API; the demonstration’s dependency version is unspecified.

use rustyline::{error::ReadlineError, DefaultEditor};

fn main() -> rustyline::Result<()> {
    let mut editor = DefaultEditor::new()?;

    loop {
        match editor.readline("db> ") {
            Ok(line) => {
                let command = line.trim();
                if command.is_empty() {
                    continue;
                }
                editor.add_history_entry(command)?;

                match command {
                    "help" => println!("Commands: help, quit"),
                    "quit" => break,
                    _ => println!("Unknown command: {command}"),
                }
            }
            Err(ReadlineError::Interrupted | ReadlineError::Eof) => break,
            Err(error) => return Err(error),
        }
    }

    Ok(())
}

In the database, the existing query handler would occupy the dispatch step. The feature changes command entry without requiring a new database engine.

The updated build succeeds with warnings; warning cleanup is deferred. The agent writes a Bash script to test history and then a final demonstration script before returning its summary. Kant closes the loop himself: rebuild, rerun, enter Help, and press the up arrow. This time command recall works. The requested interaction is checked in the running program, after the edits and generated tests.

Kant next asks for a poem about the changes, shifting from software work to creative writing. He describes the models as useful for broader knowledge work, emotionally intelligent, and enjoyable for bedtime stories. Warner adds his own anecdote about model-written love letters. The poem request is part of the demonstration, though its output is not shown in the spoken walkthrough.

VS Code is one interface into the platform. Warner also describes web access and a downloadable agent for existing customers. He then turns to the next model generation: additional compute would support training, followed by a planned public release very early the following year—early 2026 in the recording’s November 2025 context. Distribution was planned through Poolside’s own API and Amazon Bedrock. These are announcements made during the talk, not established availability; the inspected AWS page still describes the offering as coming soon.

The intended consumers include both engineering assistants—such as Cursor, Windsurf, Cognition, and Replit—and applications outside coding, such as Harvey and Writer. Warner positions Poolside as an additional model supplier at the leading tier. That is the proposed market role, rather than a comparative benchmark demonstrated by the database exercise.

Kant identifies compute as a previous constraint on capability. He reports more than 40,000 GB300s coming online to support further scaling in software development and other long-horizon knowledge work. The claim concerns incoming infrastructure, not a measured improvement in model performance.

Longer work also changes the interface problem. Kant says he and Warner already have agents performing tasks for hours, and forecasts tasks lasting days in the coming years. The asynchronous interaction shown in VS Code is one expression of that capability. As the duration and independence of work grow, he expects the surrounding interfaces to keep changing.

Poolside’s response is vertical integration: a multi-gigawatt campus under development in West Texas, teams building models, and the infrastructure to serve them. Kant treats the demonstrated interface as Poolside’s own expression of the underlying intelligence, while expecting application builders to create other ways to turn it into economically valuable work. Warner makes the physical commitment explicit: the company is putting shovels in the ground and hiring people to build the data-center campus.

Kant adds an exploratory invitation for companies doing reinforcement learning and fine-tuning. He names Qwen, Kimi, and MiniMax as model families others are building on, then proposes working with partners on Poolside checkpoints ranging from early training stages to current models. No particular versions or licensing terms are specified.

The partnership approach is not yet defined. This is an invitation to discuss collaboration, not an announced open-source release or an established checkpoint-access program. Its purpose is broader than consuming an inference API: Kant wants others to participate in building on the models themselves.

The informal Q&A turns to how the founders met. Warner recalls joining GitHub in 2017 with the ambition of turning a collaborative code host into an end-to-end development platform infused with intelligence. He describes the role retrospectively as CTO; contemporary GitHub material identified him as SVP of Technology. His account traces the platform’s expansion through Actions, Packages, Alerts, Notifications, Codespaces, and eventually Copilot, naming Nat Friedman and Oege de Moor among the collaborators.

In Warner’s recollection, Kant already had working code completion using LSTMs in 2017, before transformer architectures had fully landed. Warner tried to acquire Kant’s company, and Kant declined. The prolonged discussions about what neural networks could mean nevertheless became the basis of a friendship that continued over the following years.

Developments around ChatGPT and Anthropic in 2022 brought them back to the question of starting a company. Kant initially preferred learning to paint and sail, Warner jokes. Continued conversations eventually produced a different answer: they would build Poolside together.

Kant closes by returning to the founding technical conviction. He says the company’s first 18 months concentrated on combining reinforcement learning with LLMs, a position that felt contrarian to him then and no longer does. He places the work in a progression from completions to chat to agents, with greater autonomy still ahead.

That progression requires more than increasingly capable models. It requires bringing those models into contact with real problems and building applications that make their capabilities useful. Kant calls the unfinished transition the “awkward teenage years ahead of AGI.” In that framing, application builders bridge the distance between raw intelligence and practical value.

The closing commitment is to broaden participation. Existing enterprise customers have already had access to the capabilities demonstrated here; Poolside wants others to be able to build with them too. The work ahead includes both improving the models and making that intelligence available in forms people can turn into useful software and services.