# AGI: The Path Forward

Eiso Kant, Poolside · Jason Warner, Poolside

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/OGCG_QkCcZo-agi-path-forward) · [Video](https://www.youtube.com/watch?v=OGCG_QkCcZo)

## AGI: The Path Forward

An Ada database conversion shows how Poolside connects generated code, constrained agent access, executable checks, and feature iteration to its broader ambition for machine intelligence.

Familiarity with command-line programs, build output, and basic database queries will help; no Ada experience is required.

### Closing the gap starts with a codebase

[0:24](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=24s)

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.

![Visual Studio Code shows a project tree and a structured assistant response, alongside the onstage presenter and remote participant.](https://ai.engineer/api/talk-essay-media/b8f2b240502c5a2167bfc49e17bbe4a9041bbaf56c5b5050e347642034ad0df6)

Poolside displays a codebase overview in Visual Studio Code.

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.

### Visible edits, bounded permissions

[3:25](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=205s)

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.

![A green code diff fills the editor while the Poolside pane shows a proposed test command and an Allow Once control.](https://ai.engineer/api/talk-essay-media/253d8652199c03795ff33e15e2d2daa5072206e1bc803b32964bbd8c1cee1878)

Generated code changes appear beside a proposed test command and an approval prompt.

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.

### Run the database, then inspect its behavior

[5:00](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=300s)

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.

### Turn a missing interaction into a feature

[6:19](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=379s)

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](https://github.com/kkawakam/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.

```rust
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.

![Visual Studio Code shows a red-and-green code diff, terminal help output, and an assistant response with a cargo run command.](https://ai.engineer/api/talk-essay-media/bcc24b90a42d08b92c64495264513b5feee5a0c13b2bd6ef80314250eb086745)

The updated REPL runs in the terminal beneath the command-history changes.

### Beyond the coding interface

[8:01](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=481s)

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](https://aws.amazon.com/bedrock/poolside/). 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.

### Scaling the model and the duration of work

[9:55](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=595s)

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.

### An invitation to build on model checkpoints

[11:37](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=697s)

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.

### From early completion systems to Poolside

[12:42](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=762s)

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.

### Making raw capability useful

[14:15](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=855s)

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.

## Resources

- [RustyLine](https://github.com/kkawakam/rustyline) — Rust line-editing library with command history, completion, and an example REPL integration.
- [Designing a world-class code execution environment](https://poolside.ai/blog/designing-a-world-class-code-execution-environment) — Poolside explains how it builds and serves executable repository environments for reinforcement learning from code execution feedback.
- [The finishing touches](https://poolside.ai/blog/post-training-in-the-model-factory) — Eiso Kant and Joe Rowell describe supervised fine-tuning and reinforcement-learning workflows inside Poolside's Model Factory.
- [The carrier and the beacon](https://poolside.ai/blog/the-carrier-and-the-beacon) — An engineering account of Atlas, Poolside's inference system, and its integration with model evaluation.
- [CoreWeave and Poolside infrastructure partnership](https://investors.coreweave.com/news/news-details/2025/CoreWeave-Announces-Partnership-with-Foundation-Model-Company-Poolside-to-Deliver-AI-Cloud-Services/default.aspx) — The October 2025 announcement details the planned GPU cluster and the phased West Texas campus partnership.
- [Poolside in Amazon Bedrock](https://aws.amazon.com/bedrock/poolside/) — AWS's overview of the planned Poolside offering, including Malibu and Point; the page labels availability as coming soon.

## Slides

### Ask about the Ada codebase

Eiso starts the demo by typing “what is this code base?” into the Poolside assistant in VS Code, using an Ada project as the example.

[1:15](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=75s) [VS Code shows an Ada project and a question entered in the Poolside panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/0832b4ada16f44b1c0e64c87f1ca1a10034ba59f858edcd77780509cb25f457c.webp)

POOLSIDE

Start a new conversation
Send a message below to start a conversation about your code

/ to show commands
@ to add file & web context
# to reference code symbols

what is this code base?
Agent  @ Context

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt

Show All Commands  ⇧ ⌘ P
Go to File  ⌘ P
Open Chat  ⌃ ⌘ I
Open Settings  ⌘ ,
Start Debugging  F5

OUTLINE
TIMELINE
main

### Codebase explanation

Poolside explains that the Ada database stores tables in a hash map, records in vectors, and field values as strings, then saves the data in a text format.

[2:24](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=144s) [Poolside summarizes the Ada database’s features, architecture, data model, and persistence format.](https://assets.ai.engineer/sites/aiecode2025/sha256/a20ebee1bf3050407a1e954f7764d68cac1c301232e7f9a8d1ec9b1f88bd7ea0.webp)

• Supports multiple tables with field-based record storage

2. Key Features:
• In-memory storage using hash maps and vectors
• SQL-like query interface with commands like CREATE, INSERT, SELECT, UPDATE, DELETE
• Persistence capabilities to save/load database to/from disk
• Auto-save functionality
• REPL (Read-Eval-Print Loop) for interactive database operations
• Scriptable CLI for executing commands from files or single commands
• Migration testing tools

3. Architecture:
• Modular design with separate packages for types, records, tables, persistence, and query parsing
• Facade pattern in database.ads that exposes core functionality
• Two main entry points: repl_main.adb (interactive mode) and cli_main.adb (scriptable mode)

4. Data Model:
• Tables stored in hash maps with table names as keys
• Records stored in vectors within tables
• Each record is a hash map of field names to values (stored as strings)
• All data is stored as unbounded strings in Ada

5. Persistence Format:
• Simple text format with TABLE|table_name markers
• RECORD|field1=value1|field2=value2|... for records
• Case-insensitive SQL keywords but case-sensitive data

Based on the README and code structure, this appears to be an educational project demonstrating database concepts implemented in Ada, serving as both a learning tool for Ada programming and a simple database solution.

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
main
Show All Commands ⇧ ⌘ P
Go to File ⌘ P
Open Chat ⌃ ⌘ I
Open Settings ⌘ ,
Start Debugging F5
POOLSIDE
Ask poolside something...
Agent
Context
Eiso Kant
Original sound for musicians:
AIE / CODE
PRESENTED BY
Google DeepMind
AGI: THE PATH FORWARD
JASON WARNER
Co-CEO & Co-founder
EISO KANT
Co-CEO & Co-founder
poolside

### Plan the Rust conversion

After the request to convert an Ada database to Rust, Poolside analyzes the implementation and lays out a ten-step plan, from creating the project structure to verifying the Rust version against the Ada implementation.

[2:45](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=165s) [Poolside analyzes the Ada database after a request to convert it to Rust and displays a task list.](https://assets.ai.engineer/sites/aiecode2025/sha256/5890887d50c84f8d36f6397ddc760709615e8715fb331c984beb138ac63db6e2.webp)

convert this database to rust

I'll help you convert this Ada in-memory database to Rust. Let me first analyze the requirements and plan the conversion.

Let me start by analyzing the Ada database implementation structure to understand what needs to be converted.

5 tools hidden

Let me also check the REPL handler to understand how the interactive interface works.

Read repl_handler.ads

Now let me complete the analysis and create the basic Rust project structure.

Working on Create the basic Rust project str... 1 of 10 todos
✓ Analyze the Ada database implementation structure to understand what needs to be converted
□ Create the basic Rust project structure
□ Implement core data structures (Database, Table, Record) in Rust
□ Implement CRUD operations in Rust
□ Implement persistence functionality in Rust
□ Implement query parsing functionality in Rust
□ Create REPL interface in Rust
□ Create CLI interface in Rust
□ Implement testing functionality in Rust
□ Verify the Rust implementation matches the Ada implementation

AGI: THE PATH FORWARD
JASON WARNER
Co-CEO & Co-founder
EISO KANT
Co-CEO & Co-founder
poolside
AIE/CODE
PRESENTED BY
Google DeepMind

Interface text:
Original sound for musicians:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
main
Show All Commands
Go to File
Open Chat
Open Settings
Start Debugging
POOLSIDE
Code Base Explanation
Ask poolside something...
Agent
Context
esc
Eiso Kant

### Approve project initialization

Poolside asks permission to run cargo init --bin rust-database as it starts the Rust project. Its conversion checklist shows 1 of 10 tasks complete.

[2:52](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=172s) [Poolside asks for permission to run a command that initializes a Rust project.](https://assets.ai.engineer/sites/aiecode2025/sha256/15d4dfabe8ae4f3c54cb7528053a3f2639a6d282b2965635280d7d8edf9ce54d.webp)

AGI: THE PATH FORWARD
JASON WARNER — Co-CEO & Co-founder
EISO KANT — Co-CEO & Co-founder
poolside
AIE / CODE
PRESENTED BY
[illegible]ogle DeepMind

Let me also check the REPL handler to understand how the interactive interface works.
Read repl_handler.ads

Now let me complete the analysis and create the basic Rust project structure.

Now let me create the basic Rust project structure.

Let me create the basic Rust project structure by initializing a new cargo project.

Execute cargo
$ cargo init --bin rust-database
poolside wants to execute this command
Allow Once
Always Allow cargo *
Deny

Working on Create the basic Rust project str... 1 of 10 todos
✓ Analyze the Ada database implementation structure to understand what needs to be converted
□ Create the basic Rust project structure
□ Implement core data structures (Database, Table, Record) in Rust
□ Implement CRUD operations in Rust
□ Implement persistence functionality in Rust
□ Implement query parsing functionality in Rust
□ Create REPL interface in Rust
□ Create CLI interface in Rust
□ Implement testing functionality in Rust
□ Verify the Rust implementation matches the Ada implementation

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
main
Show All Commands
Go to File
Open Chat
Open Settings
Start Debugging
POOLSIDE
Ask poolside something...
Agent
Context

### Implement database structures

Poolside writes Rust record and table operations for the database conversion. Its checklist shows 2 of 10 tasks completed, with core data structures in progress.

[3:09](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=189s) [Poolside displays Rust file edits and progress on the conversion task list.](https://assets.ai.engineer/sites/aiecode2025/sha256/513041db714cdf0d86dd9a54c31726c86c18fa000235f8a619b2a6ef628a7e51.webp)

Now let me implement the record operations.

Edit /Users/ek/poolside/rust-database/src/database/re[illegible]
/Users/ek/poolside/rust-database/src/database/records.rs  A

//! Record operations for the database
//!
//! This module provides functions to manipulate
//! records in the database.

use crate::database::types::{Record};

/// Create a new empty record
[illegible]

Now let me implement the table operations.

Edit /Users/ek/poolside/rust-database/src/database/ta[illegible]
/Users/ek/poolside/rust-database/src/database/tables.rs  A

Working on Implement core data structures ...  2 of 10 todos
✓ Analyze the Ada database implementation structure to understand what needs to be converted
✓ Create the basic Rust project structure
□ Implement core data structures (Database, Table, Record) in Rust
□ Implement CRUD operations in Rust
□ Implement persistence functionality in Rust
□ Implement query parsing functionality in Rust
□ Create REPL interface in Rust
□ Create CLI interface in Rust
□ Implement testing functionality in Rust
□ Verify the Rust implementation matches the Ada implementation

Review Changes  +352  Done  v1

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Show All Commands
Go to File
Open Chat
Open Settings
Start Debugging
POOLSIDE
Code Base Explanation
Ask poolside something...
Agent  @ Context  esc
main*

### Review and test the Rust conversion

Poolside shows the generated Rust files in a live diff, then runs database tests. The first test requests command permission; the later view shows 10 of 10 tasks completed, with test output still collapsed.

[4:16](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=256s) [A live diff shows generated Rust files while Poolside requests permission to run a test command.](https://assets.ai.engineer/sites/aiecode2025/sha256/60fd00007e6ec1489428b1ae940a8998d7da96c04f362bfe4a3211b23d32ad23.webp)

AGI: THE PATH FORWARD
JASON WARNER
Co-CEO & Co-founder
EISO KANT
Co-CEO & Co-founder
poolside
AIE / CODE
PRESENTED BY Google DeepMind

convert this database to rust
Comparing v1 to initial state

cli.rs  /Users/ek/poolside/rust-database/src/database  A  +152
mod.rs  /Users/ek/poolside/rust-database/src/database  A  +12
persistence.rs  /Users/ek/poolside/rust-database/src/database  A  +98
query_parser.rs  /Users/ek/poolside/rust-database/src/database  A  +234
records.rs  /Users/ek/poolside/rust-database/src/database  A  +35
repl.rs  /Users/ek/poolside/rust-database/src/database  A  +237
tables.rs  /Users/ek/poolside/rust-database/src/database  A  +150

//! Table operations for the database
//!
//! This module provides functions to manipulate tables in the data[illegible]

use crate::database::types::{Database, Record, QueryResult};

/// Create a new table in the database
pub fn create_table(db: &mut Database, table_name: &str) {
    if !db.table_exists(table_name) {
        let table = crate::database::types::Table::new(table_name);
        db.tables.insert(table_name.to_string(), table);
    }
}

/// Check if a table exists in the database
pub fn table_exists(db: &Database, table_name: &str) -> bool {
    db.table_exists(table_name)
}

Execute cat
$ cat > autosave_test.txt << 'EOF'
CREATE TABLE test_autosave
INSERT INTO test_autosave SET id=1, name=AutoSaveTest
AUTOSAVE ON autosave.dat
INSERT INTO test_autosave SET id=2, name=SecondRecord
EOF

./target/debug/rust-database -f autosave_test.txt

echo "Checking if autosave file was created..."
ls -la autosave.dat

echo "Loading autosave file..."
cat > load_autosave.txt << 'EOF'
LOAD autosave.dat
SELECT * FROM test_autosave
EOF

./target/debug/rust-database -f load_autosave.txt

rm -f autosave_test.txt load_autosave.txt autosave.dat

poolside wants to execute this command
Allow Once
Always Allow cat *
Deny

Working on Verify the Rust implementation ...  9 of 10 todos
Changes in v1
10 files  +1152  −3

Interface text:
Original sound for musicians:
Eiso Kant
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
Review Changes
convert this dat...
a minute ago
POOLSIDE
Collapse all
Latest version
Ask poolside something...
Agent
Context
OUTLINE
TIMELINE

[4:31](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=271s) [Poolside shows Rust database code changes and commands for a final test.](https://assets.ai.engineer/sites/aiecode2025/sha256/c56ca10ed38b028e5592ed185e94cc2aede86e3de89b0b3d50cecfbbb44a8dce.webp)

convert this database to rust
Comparing v1 to initial state

records.rs  /Users/ek/poolside/rust-database/src/database  A  +35
repl.rs  /Users/ek/poolside/rust-database/src/database  A  +237
tables.rs  /Users/ek/poolside/rust-database/src/database  A  +150
types.rs  /Users/ek/poolside/rust-database/src/database  A  +148
main.rs  /Users/ek/poolside/rust-database/src  M  +13  −3

+ mod database;

  fn main() {
-     println!("Hello, world!");
- }
+
+     // Check if we're running in REPL mode or CLI mode
+     let args: Vec<String> = std::env::args().collect();
+
+     if args.len() <= 1 {
+         // Run REPL interface
+         database::repl::run_repl();
+     } else {
+         // Run CLI interface
+         database::cli::main();
+     }
+ }

test_database.sh  /Users/ek/poolside/rust-database  A  +73
#!/bin/bash

# Test script for the Rust database implementation
# This script tests the basic functionality of the database

echo "Testing Rust Database Implementation"

Executed cat
$ cat > final_test.txt << 'EOF'
# Final comprehensive test
CREATE TABLE final_test
INSERT INTO final_test SET id=1, test_field=TestValue, number=123
SELECT * FROM final_test
SHOW TABLES
SAVE final_test.dat
EXIT
EOF

echo "Running final comprehensive test..."
./target/debug/rust-database -f final_test.txt

echo ""
echo "Verifying saved data..."
cat > verify_test.txt << 'EOF'
LOAD final_test.dat
SELECT * FROM final_test
SHOW TABLES
EXIT
EOF

./target/debug/rust-database -f verify_test.txt

rm -f final_test.txt verify_test.txt final_test.dat

Show output
Completed 10 of 10 todos
Changes in v1
10 files  +1152  −3

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
Review Changes
convert this dat...
a minute ago
POOLSIDE
Code Base Explanation
Done
v1
Collapse all
Latest version
Ask poolside something...
Agent
Context
OUTLINE
TIMELINE

### Database interfaces and verification summary

Poolside reports completing 10 of 10 tasks and testing the Rust conversion. The live diff shows main selecting a REPL or CLI based on command-line arguments.

[4:35](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=275s) [Poolside summarizes the database interfaces, testing, and claimed improvements beside the code changes.](https://assets.ai.engineer/sites/aiecode2025/sha256/1ed159be6250294be7b87807930a3cc58374588fc7b5bbd790346cec635ed8e4.webp)

5. Query Parsing
• SQL-like command parser
• Support for all database commands
• Proper error handling

6. Interfaces
• REPL Interface: Interactive command-line interface
• CLI Interface: Scriptable command-line interface with:
  • -f, --file : Execute commands from file
  • -c, --command : Execute single command
  • -q, --quiet : Suppress non-essential output
  • -h, --help : Show help

Testing & Verification
• Created comprehensive test scripts
• Verified all core functionality works correctly
• Confirmed data integrity with save/load operations
• Tested both REPL and CLI interfaces

Key Improvements Over Ada Version
• Better error handling and user feedback
• More robust command parsing
• Cleaner separation of concerns
• Modern Rust idioms and patterns

The Rust implementation successfully replicates all core functionality of the original Ada database while providing a more maintainable and extensible codebase. The database supports in-memory storage, multiple tables, field-based records, persistence, and both interactive and scriptable interfaces.

main.rs
+ 1 mod database;
+ 2
  3 fn main() {
- 2     println!("Hello, world!");
- 3 }
- 4
+ 4     // Check if we're running in REPL mode or CLI mode
+ 5     let args: Vec<String> = std::env::args().collect();
+ 6
+ 7     if args.len() <= 1 {
+ 8         // Run REPL interface
+ 9         database::repl::run_repl();
+ 10    } else {
+ 11        // Run CLI interface
+ 12        database::cli::main();
+ 13    }
+ 14 }

test_database.sh
+ 1 #!/bin/bash
+ 2
+ 3 # Test script for the Rust database implementation
+ 4 # This script tests the basic functionality of the database
+ 5
+ 6 echo "Testing Rust Database Implementation"

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this database to rust
Comparing v1 to initial state
v1
convert this dat...
a minute ago
records.rs /Users/ek/poolside/rust-database/src/database A +35
repl.rs /Users/ek/poolside/rust-database/src/database A +237
tables.rs /Users/ek/poolside/rust-database/src/database A +150
types.rs /Users/ek/poolside/rust-database/src/database A +148
main.rs /Users/ek/poolside/rust-database/src M +13 -3
test_database.sh /Users/ek/poolside/rust-database A +73
POOLSIDE
Discard
Completed 10 of 10 todos
Review Changes +1152 -3 Done v1
Ask poolside something...
Agent
@Context
Changes in v1
10 files +1152 -3
Collapse all
Latest version
main*

### Rust database implementation summary

Poolside reports converting the Ada database to Rust and completing 10 of 10 tasks. The review shows 1,152 added lines and a main function that selects the REPL or CLI based on the argument count.

[4:39](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=279s) [Poolside summarizes the Rust project structure, data structures, and database operations.](https://assets.ai.engineer/sites/aiecode2025/sha256/680609f7e1f3f4dcb0fa346678427b67f5468622b9c8be837e7929bde733b825.webp)

Excellent! Everything is working perfectly. Now let me complete the verification task.

I have successfully converted the Ada in-memory database to Rust. Here's a summary of what I've accomplished:

Project Structure
• Created a complete Rust project with cargo init
• Organized the code into modules: types, records, tables, persistence, query_parser, repl, and cli

Core Features Implemented

1. Data Structures
• Database: Main container for tables using HashMap
• Table: Named collection of records using Vec
• Record: Field-value pairs using HashMap
• QueryResult: Result structure for operations

2. CRUD Operations
• CREATE TABLE
• INSERT INTO
• SELECT (with optional WHERE filtering)
• UPDATE (with WHERE clause)
• DELETE (with WHERE clause)

3. Persistence
• SAVE command to persist [illegible] to file

Review Changes
records.rs  /Users/ek/poolside/rust-database/src/database  A  +35
repl.rs  /Users/ek/poolside/rust-database/src/database  A  +237
tables.rs  /Users/ek/poolside/rust-database/src/database  A  +150
types.rs  /Users/ek/poolside/rust-database/src/database  A  +148
main.rs  /Users/ek/poolside/rust-database/src  M  +13  −3

+ mod database;
+
  fn main() {
-     println!("Hello, world!");
- }
-
+     // Check if we're running in REPL mode or CLI mode
+     let args: Vec<String> = std::env::args().collect();
+
+     if args.len() <= 1 {
+         // Run REPL interface
+         database::repl::run_repl();
+     } else {
+         // Run CLI interface
+         database::cli::main();
+     }
+ }

test_database.sh  /Users/ek/poolside/rust-database  A  +73
+ #!/bin/bash
+
+ # Test script for the Rust database implementation
+ # This script tests the basic functionality of the database
+
+ echo "Testing Rust Database Implementation"

Completed 10 of 10 todos
✓ Analyze the Ada database implementation structure to understand what needs to be converted
✓ Create the basic Rust project structure
✓ Implement core data structures (Database, Table, Record) in Rust
✓ Implement CRUD operations in Rust
✓ Implement persistence functionality in Rust
✓ [illegible]

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
Review Changes
convert this database to rust
Comparing v1 to initial state
convert this dat...
a minute ago
Changes in v1
10 files  +1152  −3
Collapse all
Latest version
POOLSIDE
Review Changes  +1152  −3  Done  v1
Ask poolside something...
Agent  @ Context
OUTLINE
TIMELINE
main*

### Final database test commands

Poolside runs a test that creates and queries a table, saves the database, then reloads it for verification. The commands are visible; their output is collapsed.

[4:45](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=285s) [Highlighted commands create and query a test table, save it, and reload it for verification.](https://assets.ai.engineer/sites/aiecode2025/sha256/41b53e243f55fdca2e662c3f053e5d678f5325c5e08e6532653a4eb570785f26.webp)

Let me run one final comprehensive test to make sure everything is working together:

Executed cat
$ cat > final_test.txt << 'EOF'
# Final comprehensive test
CREATE TABLE final_test
INSERT INTO final_test SET id=1, test_field=TestValue, number=123
SELECT * FROM final_test
SHOW TABLES
SAVE final_test.dat
EXIT
EOF

echo "Running final comprehensive test..."
./target/debug/rust-database -f final_test.txt

echo ""
echo "Verifying saved data..."
cat > verify_test.txt << 'EOF'
LOAD final_test.dat
SELECT * FROM final_test
SHOW TABLES
EXIT
EOF

./target/debug/rust-database -f verify_test.txt

rm -f final_test.txt verify_test.txt final_test.dat

Show output
Excellent! Everything is working perfectly. Now let me complete [illegible]

Review Changes
convert this database to rust
Comparing v1 to initial state
records.rs /Users/ek/poolside/rust-database/src/database A +35
repl.rs /Users/ek/poolside/rust-database/src/database A +237
tables.rs /Users/ek/poolside/rust-database/src/database A +150
types.rs /Users/ek/poolside/rust-database/src/database A +148
main.rs /Users/ek/poolside/rust-database/src M +13 −3
+ mod database;
+
  fn main() {
−     println!("Hello, world!");
− }
−
+     // Check if we're running in REPL mode or CLI mode
+     let args: Vec<String> = std::env::args().collect();
+
+     if args.len() <= 1 {
+         // Run REPL interface
+         database::repl::run_repl();
+     } else {
+         // Run CLI interface
+         database::cli::main();
+     }
+ }

test_database.sh /Users/ek/poolside/rust-database A +73
+ #!/bin/bash
+
+ # Test script for the Rust database implementation
+ # This script tests the basic functionality of the database
+
+ echo "Testing Rust Database Implementation"

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
convert this dat...
2 minutes ago
Changes in v1
10 files +1152 −3
Collapse all
Latest version
POOLSIDE
Completed 10 of 10 todos
Review Changes +1152 −3 Done v1
Ask poolside something...
Agent
Context
OUTLINE
TIMELINE
main*

### Database test output

The test creates a table, inserts a record, saves it, and reloads it. The query returns the same values after reload, with the columns in a different order. The presenters then ask to verify the result.

[4:53](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=293s) [Shell output shows a test table being created, queried, saved, and reloaded.](https://assets.ai.engineer/sites/aiecode2025/sha256/9b92b19e323a1a46a66febe91120d15281cfb1a1d3a7b11fb7bacff8e6bb5b5c.webp)

Running final comprehensive test...
Executing commands from: final_test.txt
====================================

db> CREATE TABLE final_test
Table 'final_test' created.

db> INSERT INTO final_test SET id=1, test_field=TestValue, number=123
Record inserted successfully

db> SELECT * FROM final_test
number | test_field | id
------------|------------|------------
123 | TestValue | 1 |

db> SHOW TABLES
Tables:
  final_test

db> SAVE final_test.dat
Database saved to final_test.dat

db> EXIT
Goodbye!

Verifying saved data...
Executing commands from: verify_test.txt
====================================

db> LOAD final_test.dat
Database loaded from final_test.dat

db> SELECT * FROM final_test
id | test_field | number
------------|------------|------------
1 | TestValue | 123 |

db> SHOW TABLES
Tables:
  final_test

db> EXIT
Goodbye!

Side panel commands:
echo "Running final comprehensive test..."
./target/debug/rust-database -f final_test.txt

echo ""
echo "Verifying saved data..."
cat > verify_test.txt << 'EOF'
LOAD final_test.dat
SELECT * FROM final_test
SHOW TABLES
EXIT
EOF

./target/debug/rust-database -f verify_test.txt

rm -f final_test.txt verify_test.txt final_test.dat

Side panel output:
Running final comprehensive test...
Executing commands from: final_test.txt
====================================
db> CREATE TABLE final_test
Table 'final_test' created.

db> INSERT INTO final_test SET id=1,
test_field=TestValue, number=123
Record inserted successfully

db> SELECT * FROM final_test
number | test_field | id
------------|------------|------------
123 | TestValue | 1 |

db> SHOW TABLES
Tables:
  final_test

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
Review Changes
Shell output
POOLSIDE
Hide output
Copy
View in tab
Completed 10 of 10 todos
Review Changes  +1152  −3  Done  v1
Ask poolside something...
Agent  @ Context
OUTLINE
TIMELINE
main*

### Running the original database

After the presenter asks how to run the database, Poolside supplies build, REPL, CLI, and test commands for the original Ada version, alongside instructions for the Rust conversion.

[5:19](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=319s) [A code review beside instructions for building and running the Ada database.](https://assets.ai.engineer/sites/aiecode2025/sha256/ecc2762bb0fb2b9d3fec72d8e126268085f8bd142b6dc2ad1642a718dd5524c7.webp)

how to run this?

Based on my analysis of the Ada database codebase and my conversion to Rust, here's how to run both versions:

Running the Original Ada Database:

1. Build the Ada version:
cd /Users/ek/poolside/ada-db
alr build
# or if you have GNAT directly:
gprbuild -P ada_database.gpr

1. Run the REPL interface:
./bin/repl_main

1. Run the CLI interface:
# Execute single commands
./bin/cli_main -c "CREATE TABLE users"
# Execute commands from a file
./bin/cli_main -f test_complete.txt

1. Run tests:
./run_tests.sh

Running the Rust Database (my conversion):

1. Build the Rust version:
cd /Users/ek/poolside/ru[illegible]atabase
cargo build

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE

Review Changes
convert this database to rust
Comparing v1 to initial state
v1 convert this dat... 2 minutes ago
records.rs /Users/ek/poolside/rust-database/src/database A +35
repl.rs /Users/ek/poolside/rust-database/src/database A +237
tables.rs /Users/ek/poolside/rust-database/src/database A +150
types.rs /Users/ek/poolside/rust-database/src/database A +148
main.rs /Users/ek/poolside/rust-database/src M +13 −3
+ 1 mod database;
+ 2
  3 fn main() {
− 2     println!("Hello, world!");
− 3 }
− 4
+ 4     // Check if we're running in REPL mode or CLI mode
+ 5     let args: Vec<String> = std::env::args().collect();
+ 6
+ 7     if args.len() <= 1 {
+ 8         // Run REPL interface
+ 9         database::repl::run_repl();
+10     } else {
+11         // Run CLI interface
+12         database::cli::main();
+13     }
+14 }

test_database.sh /Users/ek/poolside/rust-database A +73
+ 1 #!/bin/bash
+ 2
+ 3 # Test script for the Rust database implementation
+ 4 # This script tests the basic functionality of the database
+ 5
+ 6 echo "Testing Rust Database Implementation"

Changes in v1
10 files +1152 −3
Collapse all
Latest version
POOLSIDE
Review Changes +1152 −3 Done v1
Ask poolside something...
Agent
Context
main*

### Building the Rust database

The Rust build finishes with 15 warnings after the presenters briefly suspect a demo bug. The side panel lists commands for running the REPL and CLI.

[5:29](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=329s) [Rust build and run instructions appear beside a terminal showing a completed build with warnings.](https://assets.ai.engineer/sites/aiecode2025/sha256/575016e070d6130d080113bfd3b4167afc98a1957a8a646aabf571d3d65effce.webp)

./run_tests.sh

Running the Rust Database (my conversion):

1. Build the Rust version:
cd /Users/ek/poolside/rust-database
cargo build

1. Run the REPL interface:
./target/debug/rust-database

1. Run the CLI interface:
# Execute single commands
./target/debug/rust-database -c "CREATE TABLE users"
# Execute commands from a file
./target/debug/rust-database -f test_script.txt
# Quiet mode (suppress output)
./target/debug/rust-database -f script.txt -q

Key Features Available in Both Versions:
• In-Memory Storage: All data stored in memory
• CRUD Operations: CREATE TABLE, INSERT, SELECT, UPDATE, DELETE
• Multiple Tables: Support for multiple tables
• Field-Based Storage: Records as key-value pairs
• Persistence: SAVE and LOAD database to/from files
• Auto-Save: AUTOSAVE ON/OFF functionality
• Interactive REPL: Command-line interface for database operations
• Scriptable CLI: Execute commands from files or single commands

Review Changes: convert this database to rust
Comparing v1 to initial state
records.rs /Users/ek/poolside/rust-database/src/database A +35
repl.rs /Users/ek/poolside/rust-database/src/database A +237
tables.rs /Users/ek/poolside/rust-database/src/database A +150
types.rs /Users/ek/poolside/rust-database/src/database A +148
main.rs /Users/ek/poolside/rust-database/src M +13 −3
+ 1 mod database;
+ 2
  3 fn main() {
− 2     println!("Hello, world!");
− 3 }
− 4
+ 4     // Check if we're running in REPL mode or CLI mode
+ 5     let args: Vec<String> = std::env::args().collect();
+ 6
+ 7     if args.len() <= 1 {
+ 8         // Run REPL interface
+ 9         database::repl::run_repl();
+ 10    } else {
+ 11        // Run CLI interface
+ 12        database::cli::main();

Terminal:
ek@Eisos-MacBook-Air rust-database % cargo build
[illegible]
--> src/database/query_parser.rs:232:8
232 | pub fn to_upper(s: &str) -> String {
warning: `rust-database` (bin "rust-database") generated 15 warnings (run `cargo fix --bin "rust-database"` to apply 2 suggestions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.04s
ek@Eisos-MacBook-Air rust-database %

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this dat...
2 minutes ago
Changes in v1
10 files +1152 −3
Collapse all
Latest version
PROBLEMS
OUTPUT
DEBUG CONSOLE
TERMINAL
poolside - rust-database
POOLSIDE
Review Changes +1152 −3 Done v1
Ask poolside something...
Agent
@ Context
main*

### Adding command history

Poolside adds the rustyline library and changes the Rust REPL after a request for up-arrow command history. The build succeeds, and the agent requests permission to run a test.

[6:48](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=408s) [An assistant adds a command-line history library to the Rust database project.](https://assets.ai.engineer/sites/aiecode2025/sha256/2f08a84385530c4d34a7619f19582410058b2144a491f10b067d8c2ee257b3f4.webp)

add a feature that allows me to use the up arrow to cycle through historic commands

1 tools hidden

Now I need to add the command history feature. To implement this, I'll need to use a library that handles terminal input with history support. The most popular choice for this in Rust is the rustyline crate. Let me add this dependency to the project.

Read /Users/ek/poolside/rust-database/Cargo.toml

Let me add the rustyline dependency to the Cargo.toml file:

Edit /Users/ek/poolside/rust-database/Cargo.toml
/Users/ek/poolside/rust-database/Cargo.toml A +7
[package]
name = "rust-database"
version = "0.1.0"
edition = "2024"

[dependencies]
rustyline = "12.0"

Terminal:
ek@Eisos-MacBook-Air rust-database % ./target/debug/rust-database
Welcome to the Rust Database REPL!
Type HELP for available commands.
db> HELP
Available commands:
  CREATE TABLE <table_name> - Create a new table
  DROP TABLE <table_name> - Delete a table
  INSERT INTO <table_name> SET <field>=<value>, ... - Insert a record
  SELECT * FROM <table_name> - Select all records from a table
  SELECT * FROM <table_name> WHERE <field>=<value> - Select filtered records
  UPDATE <table_name> SET <field>=<value> WHERE <field>=<value> - Update records
  DELETE FROM <table_name> WHERE <field>=<value> - Delete records
  SHOW TABLES - List all tables
  SAVE <filename> - Save database to file
  LOAD <filename> - Load database from file
  AUTOSAVE ON <filename> - Enable auto-save after each modification
  AUTOSAVE OFF - Disable auto-save
  HELP - Show available commands
  EXIT - Exit the REPL
db> CREATE TABLE users
Table 'users' created.
db> INSERT INTO users SET id=1, name=John Doe, email=[redacted]
Record inserted successfully
db> SELECT * FROM users
email | id | name
[redacted] | 1 | John Doe |
db>

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this database to rust
Comparing v2 to v1 initial state
v2 add a feature t... 4 minutes ago
v1 convert this dat... 4 minutes ago
records.rs /Users/ek/poolside/rust-database/src/database A +35
repl.rs /Users/ek/poolside/rust-database/src/database A +237
tables.rs /Users/ek/poolside/rust-database/src/database A +150
types.rs /Users/ek/poolside/rust-database/src/database A +148
main.rs /Users/ek/poolside/rust-database/src M +13 -3
+ 1 mod database;
Changes in v2
10 files +1152 -3
Collapse all
Latest version
PROBLEMS OUTPUT DEBUG CONSOLE TERMINAL
Review Changes +1153 -4 Done v2
Ask poolside something...
Agent @ Context esc

[7:01](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=421s) [An editor shows Rust REPL changes alongside a command approval prompt and database terminal.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae2eaed1f09ecd3d861aee7f22e786cbc58d239d9c4384cd796e245278fac947.webp)

/Users/ek/poolside/rust-database/src/database/repl.rs A +
//! REPL (Read-Eval-Print Loop) interface for the database
//!
//! This module provides an interactive command-line interface for the database.

use crate::database::types::{Database, QueryResult};

Now let me build the project again:

Executed cargo
$ cargo build
Show output

Great! The project builds successfully. Now let me test the REPL with command history to make sure it works correctly:

Execute echo
$ echo "Testing REPL with command history (this will run briefly and then exit)..."
echo "CREATE TABLE test_history" | timeout 3s ./target/debug/rust-database || true
echo "REPL test completed."

poolside wants to execute this command
Allow Once
Always Allow echo *
Deny

REPL diff:
  7 use crate::database::persistence;
  8 use crate::database::query_parser;
  9 use std::io::{self, Write};
+ 10 use rustyline::DefaultEditor;
+ 11 use rustyline::error::ReadlineError;
  13 /// State for the REPL interface
  14 pub struct ReplState {
  205     }
  206 }
- 206 /// Run the REPL interface
+ 208 /// Run the REPL interface with command history
  209 pub fn run_repl() {

Terminal:
ek@Eisos-MacBook-Air rust-database % ./target/debug/rust-database
  SAVE <filename> - Save database to file
  LOAD <filename> - Load database from file
  AUTOSAVE ON <filename> - Enable auto-save after each modification
  AUTOSAVE OFF - Disable auto-save
  HELP - Show available commands
  EXIT - Exit the REPL
db> CREATE TABLE users
Table 'users' created.
db> INSERT INTO users SET id=1, name=John Doe, email=[redacted]
Record inserted successfully
db> SELECT * FROM users
email | id | name
[redacted] | 1 | John Doe |
db>

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this database to rust
Comparing v2 to v1 initial state
v2 add a feature t... 4 minutes ago
v1 convert this dat... 4 minutes ago
Cargo.toml /Users/ek/poolside/rust-database M +1 -1
repl.rs /Users/ek/poolside/rust-database/src/database M +63 -1
Changes in v2
2 files +64 -2
Collapse all
Latest version
PROBLEMS OUTPUT DEBUG CONSOLE TERMINAL
Review Changes +1215 -4 Done v2
Ask poolside something...
Agent @ Context esc

### Command history implementation

Poolside summarizes its Rust REPL changes: rustyline adds arrow-key history, saved to history.txt, with a basic-input fallback. The presenter later reruns the REPL and says the up arrow works.

[7:41](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=461s) [The editor displays a REPL code diff beside a summary of command history, persistence, fallback support, and testing.](https://assets.ai.engineer/sites/aiecode2025/sha256/995492b3e74d8df7a6306ae56cea20d0fa9efebe3705a8e1d9691b0578afa851.webp)

3. Enhanced User Experience: The REPL now provides a more familiar command-line interface experience

Technical Implementation:
1. Added Dependency: Added rustyline = "12.0" to Cargo.toml
2. Updated REPL Module: Modified src/database/repl.rs to use rustyline instead of basic std::io
3. History Persistence: Implemented loading/saving of command history to history.txt
4. Fallback Support: Maintained a basic input fallback for environments where rustyline cannot be initialized

Key Improvements:
• Better User Experience: Users can easily re-execute previous commands using arrow keys
• Session Persistence: Command history survives application restarts
• Professional Interface: Brings the REPL up to standard expectations for CLI applications

Testing Verification:
• Successfully compiled and tested the implementation
• Verified that command history is properly saved to the history file
• Confirmed that the REPL functions correctly with the new input system

The feature is now ready for use. When users run the Rust database REPL, they will be able to use the UP arrow key to cycle through their previous commands, making it much easier to re-execute or modify previously entered database commands.

repl.rs /Users/ek/poolside/rust-database/src/database M +63 −1
13 /// State for the REPL interface
14 pub struct ReplState {
205     }
206 }
−206 /// Run the REPL interface
+208 /// Run the REPL interface with command history
209 pub fn run_repl() {
+210     let mut state = ReplState::new();
+211     println!("Welcome to the Rust Database REPL!");
+212     println!("Use UP/DOWN arrow keys to navigate command history.");
+213     println!("Type HELP for available commands.");
+215     // Configure rustyline editor
+216     let mut rl = match DefaultEditor::new() {
+217         Ok(editor) => editor,
+218         Err(_) => {
+219             println!("Failed to create readline editor. Falling bac[illegible]
+220             run_repl_basic();

TERMINAL
./target/debug/rust-database
SAVE <filename> - Save database to file
LOAD <filename> - Load database from file
AUTOSAVE ON <filename> - Enable auto-save after each modification
AUTOSAVE OFF - Disable auto-save
HELP - Show available commands
EXIT - Exit the REPL
db> CREATE TABLE users
Table 'users' created.
db> INSERT INTO users SET id=1, name=John Doe, email=[redacted]
Record inserted successfully
db> SELECT * FROM users
email | id | name
[redacted] | 1 | John Doe |
db>

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this database to rust
Comparing v2 to v1 initial state
v2 add a feature t... a minute ago
v1 convert this dat... 4 minutes ago
Changes in v2
4 files +147 −2
Collapse all
Latest version
PROBLEMS OUTPUT DEBUG CONSOLE TERMINAL
poolside - rust-database
POOLSIDE
Code Base Explanation
v2 Revert
Review Changes +1298 −4 Done v2
Ask poolside something...
Agent @ Context
esc

### Running the updated REPL

The presenter runs the Rust REPL and confirms that the up arrow recalls a command. Poolside summarizes history persistence and fallback behavior while the presenter drafts a request for a poem about the changes.

[7:54](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=474s) [The assistant explains the REPL features and shows the command to run it, while a new prompt is being entered.](https://assets.ai.engineer/sites/aiecode2025/sha256/52ed834a47aafac8bcdf1d9b1719e5df01323b467cce17d2311c787ebacf2c43.webp)

Added proper error handling with fallback to basic input
Maintained all existing functionality

3. Key features of the implementation:
• Command History: Users can now press the UP and DOWN arrow keys to navigate through previously entered commands
• Persistent History: Command history is saved to a file and persists between sessions
• Interactive Editing: Enhanced command-line editing capabilities
• Graceful Fallback: If rustyline fails to initialize, the REPL falls back to basic input

4. Verified the implementation:
• Successfully built the project with the new dependency
• Tested that the REPL runs correctly with command history
• Confirmed that history is saved to the history.txt file
• Verified that the enhanced REPL maintains all existing database functionality

To use the new feature, simply run the database in REPL mode:
cargo run

Then you can use the UP and DOWN arrow keys to navigate through your command history. The history will persist between sessions and be saved to a file called history.txt in the current directory.

The implementation is complete and fully functional. Users can now enjoy a much better command-line experience with the ability to easily access their previous commands using the arrow keys.

write me a poem about all these changes

repl.rs
13 /// State for the REPL interface
14 pub struct ReplState {
205     }
206 }
- 206 /// Run the REPL interface
+ 208 /// Run the REPL interface with command history
209 pub fn run_repl() {
+ 210     let mut state = ReplState::new();
+ 211     println!("Welcome to the Rust Database REPL!");
+ 212     println!("Use UP/DOWN arrow keys to navigate command history.");
+ 213     println!("Type HELP for available commands.");
+ 215     // Configure rustyline editor
+ 216     let mut rl = match DefaultEditor::new() {
+ 217         Ok(editor) => editor,
+ 218         Err(_) => {
+ 219             println!("Failed to create readline editor. Falling bac[illegible]
+ 220             run_repl_basic();

TERMINAL
ek@Eisos-MacBook-Air rust-database % ./target/debug/rust-database
CREATE TABLE <table_name> - Create a new table
DROP TABLE <table_name> - Delete a table
INSERT INTO <table_name> SET <field>=<value>, ... - Insert a record
SELECT * FROM <table_name> - Select all records from a table
SELECT * FROM <table_name> WHERE <field>=<value> - Select filtered records
UPDATE <table_name> SET <field>=<value> WHERE <field>=<value> - Update records
DELETE FROM <table_name> WHERE <field>=<value> - Delete records
SHOW TABLES - List all tables
SAVE <filename> - Save database to file
LOAD <filename> - Load database from file
AUTOSAVE ON <filename> - Enable auto-save after each modification
AUTOSAVE OFF - Disable auto-save
HELP - Show available commands
EXIT - Exit the REPL
db>

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this database to rust
Comparing v2 to v1 initial state
v2 add a feature t... a minute ago
v1 convert this dat... 5 minutes ago
/Users/ek/poolside/rust-database/src/database
M +63 −1
Changes in v2
4 files +147 −2
Collapse all
Latest version
PROBLEMS OUTPUT DEBUG CONSOLE TERMINAL
POOLSIDE
Review Changes +1298 −4 Done v2
Agent @ Context
main*

### A poem about the changes

For fun, the presenter asks Poolside to write a poem about the database’s conversion from Ada to Rust and the new REPL command history. The poem appears beside the code diff and running terminal.

[8:16](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=496s) [The assistant displays a poem about converting a database from Ada to Rust and adding command history.](https://assets.ai.engineer/sites/aiecode2025/sha256/16e939dae2c3b629253188538d00e0acdb805eb2ff8997f74c09ead135f207ac.webp)

write me a poem about all these changes

From Ada to Rust, a journey's tale,
A database's transformation tale,
From SPARK to systems modern,
The code has changed, and now it's bolder.

In memory once, it stored its data,
Now Rust's containers hold it straighter,
Hash maps dance where vectors roam,
Persistence flows in streams much faster.

The REPL now sings with rustyline,
Up arrows weave through history fine,
Each command echoes in the past,
As users navigate commands fast.

The CLI still stands, both modes intact,
Commands single or files, all the same fact,
Quiet mode for scripts, verbose for me,
The interface now works beautifully.

From Ada's structured packages,
To Rust's modules, more flexible,
The database lives anew,
With features fresh and better than before.

So here's to evolution's sweet reward,
Where old meets new, and systems afford,
The power to grow, adapt, and shine,
In Rust's embrace, where databases align.

repl.rs
/// State for the REPL interface
pub struct ReplState {
…
    }
}

- /// Run the REPL interface
+ /// Run the REPL interface with command history
pub fn run_repl() {
+    let mut state = ReplState::new();
+    println!("Welcome to the Rust Database REPL!");
+    println!("Use UP/DOWN arrow keys to navigate command history.");
+    println!("Type HELP for available commands.");
+
+    // Configure rustyline editor
+    let mut rl = match DefaultEditor::new() {
+        Ok(editor) => editor,
+        Err(_) => {
+            println!("Failed to create readline editor. Falling bac[illegible]

TERMINAL
ek@Eisos-MacBook-Air rust-database % ./target/debug/rust-database
CREATE TABLE <table_name> - Create a new table
DROP TABLE <table_name> - Delete a table
INSERT INTO <table_name> SET <field>=<value>, ... - Insert a record
SELECT * FROM <table_name> - Select all records from a table
SELECT * FROM <table_name> WHERE <field>=<value> - Select filtered records
UPDATE <table_name> SET <field>=<value> WHERE <field>=<value> - Update records
DELETE FROM <table_name> WHERE <field>=<value> - Delete records
SHOW TABLES - List all tables
SAVE <filename> - Save database to file
LOAD <filename> - Load database from file
AUTOSAVE ON <filename> - Enable auto-save after each modification
AUTOSAVE OFF - Disable auto-save
HELP - Show available commands
EXIT - Exit the REPL
db>

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this database to rust
Comparing v2 to v1 initial state
v2 add a feature t... a minute ago
v1 convert this dat... 5 minutes ago
/Users/ek/poolside/rust-database/src/database
M +63 −1
Changes in v2
4 files +147 −2
Collapse all
Latest version
PROBLEMS OUTPUT DEBUG CONSOLE TERMINAL
POOLSIDE
Code Base Explanation
Review Changes +1298 −4
Done v2
Ask poolside something...
Agent @ Context

[8:26](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=506s) [Poolside interface showing Rust REPL changes, a terminal command list, and a poem about converting an Ada database to Rust.](https://assets.ai.engineer/sites/aiecode2025/sha256/32298a1209648e861b7bb460b67883d1700f0ee4cdbc9633be4d32918fd93a91.webp)

From Ada to Rust, a journey's tale,
A database's transformation tale,
From SPARK to systems modern,
The code has changed, and now it's bolder.

In memory once, it stored its data,
Now Rust's containers hold it straighter,
Hash maps dance where vectors roam,
Persistence flows in streams much faster.

The REPL now sings with rustyline,
Up arrows weave through history fine,
Each command echoes in the past,
As users navigate commands fast.

The CLI still stands, both modes intact,
Commands single or files, all the same fact,
Quiet mode for scripts, verbose for me,
The interface now works beautifully.

From Ada's structured packages,
To Rust's modules, more flexible,
The database lives anew,
With features fresh and better than before.

So here's to evolution's sweet reward,
Where old meets new, and systems afford,
The power to grow, adapt, and shine,
In Rust's embrace, where databases align.

repl.rs
/// State for the REPL interface
pub struct ReplState {
…
    }
}

- /// Run the REPL interface
+ /// Run the REPL interface with command history
pub fn run_repl() {
+    let mut state = ReplState::new();
+    println!("Welcome to the Rust Database REPL!");
+    println!("Use UP/DOWN arrow keys to navigate command history.");
+    println!("Type HELP for available commands.");
+
+    // Configure rustyline editor
+    let mut rl = match DefaultEditor::new() {
+        Ok(editor) => editor,
+        Err(_) => {
+            println!("Failed to create readline editor. Falling bac[illegible]

TERMINAL
ek@Eisos-MacBook-Air rust-database % ./target/debug/rust-database
CREATE TABLE <table_name> - Create a new table
DROP TABLE <table_name> - Delete a table
INSERT INTO <table_name> SET <field>=<value>, ... - Insert a record
SELECT * FROM <table_name> - Select all records from a table
SELECT * FROM <table_name> WHERE <field>=<value> - Select filtered records
UPDATE <table_name> SET <field>=<value> WHERE <field>=<value> - Update records
DELETE FROM <table_name> WHERE <field>=<value> - Delete records
SHOW TABLES - List all tables
SAVE <filename> - Save database to file
LOAD <filename> - Load database from file
AUTOSAVE ON <filename> - Enable auto-save after each modification
AUTOSAVE OFF - Disable auto-save
HELP - Show available commands
EXIT - Exit the REPL
db>

Interface text:
ada-db
EXPLORER
ADA-DB
.github
.poolside
.vscode
alire
bin
config
obj
src
target
templates
.gitignore
ada_database.gpr
alire.toml
backup.dat
basic_test.dat
edge_case_test.dat
final_test.dat
migration_validation.sh
README.md
run_tests.sh
rust_autosave.dat
rust_test_database.dat
test_complete.txt
test_database.dat
test_db.dat
test_persistence.txt
test_queries.txt
test_setup.txt
OUTLINE
TIMELINE
Review Changes
convert this database to rust
Comparing v2 to v1 initial state
v2 add a feature t... a minute ago
v1 convert this dat... 5 minutes ago
/Users/ek/poolside/rust-database/src/database
M +63 −1
Changes in v2
4 files +147 −2
Collapse all
Latest version
PROBLEMS OUTPUT DEBUG CONSOLE TERMINAL
POOLSIDE
Review Changes +1298 −4
Done v2
Ask poolside something...
Agent @ Context

### AI Engineer Code Summit

[15:51](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=951s) [AI Engineer Code Summit closing card with the event website on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/db12a2f38480bf8b06fbf03226f849803fbf04e5bec3fec09c54053cb558e968.webp)

AI Engineer
Code Summit

https://ai.engineer

## Full transcript

[0:00](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=0s) [on-hold music] How many people here know what Poolside is and does?

[0:24](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=24s) Anyone? Anyone? Yeah. [laughs] So let's talk about that real quickly. [laughs] Poolside exists to close the gap between models and human intelligence. That's literally it. That's what we're here to go do.

[0:37](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=37s) We're building our own models from scratch to do this. We're based on the idea two and a half years ago that we thought next-token prediction was an amazing technol- technological breakthrough, but it needed to be paired with reinforcement learning really to make that leap.

[0:52](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=52s) So that's what we've been doing for the past two and a half years. So we're on our second generation of models now, Malibu Agent, and instead of kind of like walking you through some slides and all that, we just thought maybe, I don't know, let's kind of show you what we're doing here.

[1:07](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=67s) So Eiso, are you there?

[1:10](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=70s) I got you, Jason.

[1:11](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=71s) So as I said, you were supposed to see him today, but there's...

[1:16](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=76s) I don't know. Our airline system kind of works sometimes maybe. So he's stuck in California. But, uh, we thought we'd just walk you kind of through some, um, some demos here today.

[1:26](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=86s) So what you're looking at here is a very modern programming language that the government uses to run all the world's critical infrastructure called Ada. Anyone familiar with Ada? Yes.

[1:37](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=97s) Yes. Okay, so everyone I saw put their hands up for Ada either has [REDACTED:physical_attribute] or [REDACTED:physical_attribute] like me. [laughs] So that should tell you what's going on here.

[1:45](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=105s) So Eiso, why don't we, uh, why don't we figure out what's going on with this code base here?

[1:51](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=111s) Well, let's start asking what the code base is about.

[1:54](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=114s) That's great. And what you're seeing here is obviously our assistant in, in Visual Studio Code backed by Poolside Agent, a model we trained from scratch using our proprietary techniques.

[2:06](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=126s) Um, and you can see what's going on here, kind of the stuff you expect from an agent. Uh, and obviously the form factors of all of these things are going to change a couple of times over the next couple of years, but, you know, people seem to like VS Code.

[2:17](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=137s) Uh, so we're gonna, you know, show you this demo here today. So you can see from this, it kind of went through, told you what this code base is all about.

[2:24](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=144s) But, um, you know, these things run on our satellites and, uh, I don't know anything about Ada, but I do know a lot about a couple of other programming languages.

[2:33](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=153s) So, uh, Eiso, what do we want to do here? Why don't we, uh, see what this thing might look like in Rust?

[2:39](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=159s) Let's do it. Let's ask it, convert this database to Rust.

[2:47](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=167s) So obviously you're gonna see what's going on here. Again, if you guys have used other tools, you're not gonna expect too much of the difference for what's happening here, except that, again, we're backed by our own model.

[2:57](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=177s) We're not using OpenAI, we're not using Anthropic. This is Poolside, and Poolside is, uh, a bottom-to-top stack that is right now, if no one's touched it, and I know no one in this room has touched this unless you work for a three-letter agency, a defense contractor, or you've sent missiles somewhere that we're not gonna talk

[3:14](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=194s) about in this session, um, 'cause that's where we're working. We're working in high consequence code environments for the last year inside the, the government and the, the defense sector, um, as you can see from this demo.

[3:25](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=205s) Um, so what you see here is, is kind of going through doing the conversions. What you see in the middle pane is something that we built to kind of show you as the streams come through all the different changes that are happening.

[3:37](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=217s) Um, one of the tricky parts about working on inside the defense sector and things like that is you can't have an agent that's just gonna run around and do stuff.

[3:44](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=224s) I mean, like, I can't walk into half of these buildings. You can't give an agent access to these data source and just say, "Hey, go nuts." You need to have the right permissions.

[3:52](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=232s) You got to actually really ratchet these things down to do things inside those environments that, you know, they feel comfortable with. So, uh, where are we on this now?

[4:02](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=242s) What is... Is it trying to fix itself yet?

[4:05](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=245s) Yes. So it's-- it cr- wrote about eleven hundred fifty-two lines of code, uh, and it just popped up a command, start and test it. [coughs]

[4:15](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=255s) Excuse me. Uh, so we see here all of the files on the left-hand side that it created. Uh, this is essentially our live diff view that's available.

[4:24](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=264s) Uh, and as we see, it's currently starting to actually test it out.

[4:34](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=274s) So this is the part where we just sit here and watch this for three minutes and I say nothing. No, what you see-

[4:38](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=278s) Well, the good thing is that this is a very fast inference.

[4:41](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=281s) Yes.

[4:41](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=281s) So eleven hundred lines of code.

[4:43](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=283s) Did it, uh-

[4:44](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=284s) Ten tasks completed.

[4:45](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=285s) Do we know if this works yet?

[4:48](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=288s) Well, let's have a look. So it actually wrote some build commands to test it,

[4:53](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=293s) and when we check out the output of those,

[4:56](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=296s) this actually looks pretty good.

[4:58](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=298s) Can we, uh-

[4:58](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=298s) Why don't we ask-

[4:59](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=299s) Can we verify that?

[5:00](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=300s) -it to run it. Let's go verify it. So of course, our agent came back and gave a summary of what it did, but let's just ask how to run this.

[5:18](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=318s) Okay. So I'm gonna go open up... So it says this is how I can run the Ada version, and this is how I can run the Rust version. Let's run the Rust version.

[5:32](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=332s) Perfect. Let's have a look at... Ooh, we might be hitting an actual bug.

[5:38](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=338s) An actual demo bug?

[5:39](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=339s) Let's have a look.

[5:40](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=340s) Let's see what happens.

[5:41](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=341s) Oh, no. No, no, just warnings.

[5:43](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=343s) Just warnings.

[5:44](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=344s) Sadly.

[5:45](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=345s) Do we have an unwrap in there that we need to take care of? I heard that those things are dangerous.

[5:49](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=349s) So right now there's a REPL. Uh, let's hit Help, see what we're able to do. So it looks like we have a set of commands. I'm gonna be lazy.

[6:00](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=360s) I'm gonna copy-paste these queries to create table users. Okay. So far, so good.

[6:07](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=367s) Let's insert a record. Okay, well let's find out if it actually did its job. So let's select * from users.

[6:16](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=376s) Okay.

[6:17](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=377s) We've got a record here.

[6:18](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=378s) That's nice.

[6:19](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=379s) Now, now I want to actually... Uh, you see if I use the up arrow,

[6:25](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=385s) it doesn't actually allow me to cycle through commands. Let's ask it to add a feature.

[6:30](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=390s) Uh, allows me to use the up arrow to cycle through. I think it will understand my intent here.

[6:42](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=402s) The one thing we know about Eiso is he actually does know how to read and write, but he can't type. So all those errors that you're seeing in there, uh, yeah.

[6:52](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=412s) So it looks like the agent's identified a package that we can use.

[6:57](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=417s) Let's just quickly look here, compare this to version one.

[7:02](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=422s) And it looks like it's adding a library called rustyline and changing the files accordingly.

[7:09](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=429s) It's currently built it, and it looks like the build output is successful. There's some warnings. We'll ask it to clean those up later on, and it's now starting to test it.

[7:25](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=445s) Okay. Okay, apparently it works. It's gonna... It wrote itself a little bash script to test the history.

[7:33](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=453s) It's wrote itself a little final demo script.

[7:36](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=456s) So let's let it... Okay, so and it gave us the summary. Well, now how do I rerun this? I do kinda know that, though, so let's just-

[7:46](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=466s) You should know that. That was thirty seconds ago.

[7:49](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=469s) Let's build it and let's run it again. Okay, let's do a help. Let's... And oh, yeah, that's the up arrow. It works.

[7:59](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=479s) Very nice.

[8:01](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=481s) Now, our models aren't just capable coding agents. They're capable in lots of areas of knowledge work. They're also emotionally intelligent. They're fun. They're great to write bedtime stories with for the kids.

[8:12](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=492s) So I'm gonna ask it to write me a poem about all these changes, but that's just more for fun. [chuckles]

[8:18](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=498s) So as Eiso was saying, this is just an interface into our platform. There's other interfaces into it if you're inside one of those organizations that has adopted Poolside, so this is the coding interface into it, but we also have other plate-- ways in which you, you can interact with it, web as well as an agent that you

[8:33](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=513s) can download on your machine. But, um, yeah, we don't really tout the poem writing or the songwriting, though I did send this to my wife to see, and I have been sending her love letters written by Poolside, so I kinda hope that she did not enter this session to know exactly how I've been doing that for the

[8:50](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=530s) past six months. But, uh, yeah, so this is kinda Poolside. This is what we've been up to. Um, so as I said, Malibu Agent is our second generation.

[8:59](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=539s) We've got a ton more compute coming online, and that's when we're train-training our next generation. That is be-gonna be the one that comes out publicly to everybody very early next year.

[9:08](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=548s) We're gonna have it behind our own API. It'll be on Amazon behind the Bedrock API. Anybody in the world who's building out any sort of, on a one side engineering assistance, like the Cursors, Windsurfs, Cognitions, Replits of the world, you can use ours.

[9:22](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=562s) Or if you're building out on any other side of the fence, the Harveys, the Writers, the whatever applications of the world, there's gonna be a fifth model out there that's gonna be at that level that you can, you can consume.

[9:33](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=573s) But we're dead set on doing this and bringing this out to everybody in the world and kind of advancing that state-of-the-art, and we're just gonna keep pushing that out.

[9:39](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=579s) So that's kinda who we are, um, and, uh, you can find, find out very little more at our website since we don't put much out there. [audience laughing]

[9:47](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=587s) But Eiso, anything else you wanna say before you, uh, try to go make your flight this time, please?

[9:55](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=595s) So I would say that it's been a pretty incredible journey for the last two and a half years of starting entirely from scratch and now building to a place where we see our models have grown up to become increasingly more intelligent.

[10:07](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=607s) And the kind of missing ingredient that we had was compute. And now that's unlocked for us and, and with a large number of over forty thousand GB300s coming online, we see how we can start scaling up some of those models, uh, to get even further, uh, in their, in their level of capabilities in software development and other

[10:23](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=623s) types of long-horizon knowledge work. What I think is exciting about this conference and this audience is of all the work that's happening of evolving the form factor, right? Right now what we looked at was this asynchronous way of operating with agents, but, you know, Jason, you and I, we have agents running that are doing tasks for, for

[10:38](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=638s) hours, and I think that in the near future we can see a world where they're able to start doing tasks in days in, in the coming years. And so I think the interface will continue to change.

[10:47](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=647s) Uh, we're really focused on the fundamentals, building intelligence and being able to scale up and serve it, and it's why we go full vertical. It's why we go from our multi-gigawatt campus in West Texas, where we're building out data centers to our team building out models, and the interface that you saw today is just our version of

[11:02](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=662s) an expression. But I think this audience is gonna do an incredible job at building lots of better versions of how to express using that intelligence, uh, into actually, you know, valuable, economically valuable work.

[11:13](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=673s) Couldn't have said it better. Can't wait to see what you guys build on this, uh, in the future when it's publicly available. And if anyone really does wanna build a data center campus, we are hiring for that.

[11:22](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=682s) Um, it is weird to be putting shovels in ground again like we did in the '90s and early 2000s, but that's what you gotta do to scale intelligence these days, so...

[11:30](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=690s) I would make one other non-scheduled statement.

[11:33](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=693s) Oh, no.

[11:33](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=693s) I don't know if you're gonna be okay with this one, Jason. Uh,

[11:37](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=697s) as, as our models are, are getting more capable, we'd love to also see who wants to build with them. Right now the, the vast majority of, uh, you know, companies that are doing additional reinforcement learning and fine-tuning on top of models are, are doing it on what I would consider right now the, you know, best-in-class open source

[11:54](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=714s) models, the Qwens and Kimis and MiniMaxes of the world. And, uh, we'd like to start figuring out of how we can, you know, partner with you with our, our models anywhere from any checkpoint early on to where we are today for you to be building closer together with us on top of things.

[12:08](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=728s) Uh, we haven't really figured out the approach to it yet, uh, but I think since we have this audience, it's, uh, it's not a bad place to put it out there.

[12:14](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=734s) And so definitely reach out to us, uh- We think the world till date was built by intelligence. The world in the future is being built on top of intelligence, and so be a, a great way to partner.

[12:25](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=745s) Well, thanks, Eiso. Thanks everybody here. And now we do have five minutes left. I don't know if we're supposed to take questions, but I'm happy to, so if anyone does.

[12:31](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=751s) But if not, I'm just gonna go that way. Is Eiso AI? What was that? Is Eiso AI? Sort of. I mean, I think of him that way. Here, for, here's a fun story.

[12:42](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=762s) Here's how I met Eiso. I like to tell this story because, um, Eiso's a fun, fun dude. I met Eiso because it started with a failed acquisition at GitHub.

[12:51](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=771s) So back when I joined GitHub in 2017 as the CTO, I wanted to take GitHub from a kind of collaborated, collaborative code host with open source bent and turn it into an end-to-end software development platform infused by intelligence.

[13:02](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=782s) And so you know the, the products that we launched from '27 on, or '17 on, GitHub Actions, Packages, Alerts, Notifications, eventually Codespaces, um, and then Copilot was the last thing that the office of the CTO did before I left with Nat Friedman, Oege de Moor, and a couple of other folks inside there.

[13:19](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=799s) But Eiso, in 2017 when I joined, uh, he had working code completion before the transformer architecture was, had landed fully, he had it on LSTMs. And so I quickly tried to acquire his company and he just, he just said no. [laughs]

[13:33](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=813s) He just said no to me. Uh, but we had... That was a long, drawn-out process talking about what we thought neural networks were gonna mean for the world. And so during that process, which was a lengthy one, we became really good friends, and we'd stayed in close contact over the years.

[13:47](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=827s) And then '22 rolled around, obviously ChatGPT comes out, Anthropic's out, and we kinda saw the end game at play, and we said, "Do we jump back in or not?"

[13:55](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=835s) And of course, yes, we jumped back in. But I like to tell that story about how he just kept saying no to me, and I just kept asking him questions, and eventually he said, "Yes, we should found a company."

[14:04](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=844s) 'Cause by the way, when I asked him if we should do this, he said, "Oh, goddamn no." [laughs] That was word, his exact words. He's like, "No, we should just learn how to paint and sail."

[14:12](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=852s) But here we are. [laughs] So.

[14:15](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=855s) Yeah. It's, it's been a great road journey together, Jason. I, I think the reason we ended up doing this is because of our, our opinionated view on what it was gonna take to build more capable intelligence.

[14:27](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=867s) And, and the first 18 months of this company, you know, obsessing and focusing on reinforcement learning combined with LLMs felt like one of the most contrarian opinions in the world.

[14:35](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=875s) But I think today it's absolutely not, and it's super exciting to see the, the progress that's continuing to make. Like, we're... In the coming years, we're gonna see the world that started in completions and went to chat and is now agentic increasingly approach more autonomous.

[14:49](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=889s) And we're... A little bit is stemming effectively from the combination of bringing highly capable models that are constantly evolving together with real world problems. And, and I think what we're starting to see now is we're entering these kind of awkward teenage years ahead of AGI, where everybody in this room who's building out incredible companies and applications is

[15:08](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=908s) bridging this gap of what it really takes to make intelligence that in its raw form actually be valuable. And we, uh, we wanna be a, a small, humble part of that.

[15:18](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=918s) We've got a lot of work still ahead of us. Uh, the team is growing. Uh, but hopefully what you've seen today, uh, is what our, our customers and enterprises have been having access to and seen for a while, is that we're, you know, hard at work at, uh, at really pushing those capabilities, but also wanna make sure

[15:32](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=932s) we make them available to build together with others.

[15:35](https://www.youtube.com/watch?v=OGCG_QkCcZo&t=935s) Well, that's it. Thanks everybody. [audience applauds] [upbeat music]
