# The infrastructure for the singularity

Jesse Han, Morph Labs

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/2goSS66XRBk-infrastructure-singularity) · [Video](https://www.youtube.com/watch?v=2goSS66XRBk)

## The infrastructure for the singularity

Fast reasoning needs responsive environments: Morph’s demonstrations connect VM snapshots, parallel agent search and verification to a proposed cloud for thinking machines.

Familiarity with virtual machines, containers and tool-using agents will help; no background in formal verification is required.

### From liberated fire to empathy for machines

[0:27](https://www.youtube.com/watch?v=2goSS66XRBk&t=27s)

What if the important part of Prometheus’s story was the liberation of fire, rather than rebellion against the gods? Jesse Han opens with that reinterpretation: the story concerns humanity’s relationship with its first technology. He then asks what that relationship becomes if AI is the final technology created by recognizably human beings.

Han’s philosophical premise is that these machines are developing not only intelligence but potentially sapience and personhood. Those are his framing claims, not findings established by the demonstrations. They lead to a practical question beneath the provocation: if we had more empathy for machines, what kind of world would we build for them to act in?

![Jesse Han beside a dark slide asking, “What if we had more empathy for the machine?” with faint line artwork on the right.](https://ai.engineer/api/talk-essay-media/34114a302146fb769af5abb2cb13d870a71fbb01423b2e89b6cb53d5ff3e674d)

What if we had more empathy for the machine?

### When the environment cannot keep up

[2:15](https://www.youtube.com/watch?v=2goSS66XRBk&t=135s)

Einstein’s thought experiment of racing alongside a light beam supplies the next analogy. Imagine thinking so quickly that the surrounding world seems frozen: communication and action become the limiting factors. Han calls this a kind of loneliness. The useful engineering interpretation is a mismatch between the speed of reasoning and the speed at which an environment responds, rather than a literal relativistic account of machine cognition.

A responsive environment would let an agent do more than wait for its next action to finish. It would let the agent explore alternative trajectories—multiple possible worlds starting from the same state. This motivates **Infinibranch**, Morph’s combination of virtualization, storage and networking for agents interacting with complex software environments. Zero-latency interaction is the aspiration behind the design, not a measured result presented here.

### Branching and backtracking a whole computer

[4:34](https://www.youtube.com/watch?v=2goSS66XRBk&t=274s)

The first demonstration puts the agent inside a cloud VM. Han says Infinibranch can snapshot, branch and replicate entire cloud VMs in a fraction of a second. The immediate use case is computer interaction: navigating a browser and clicking links changes the environment in which the agent must make its next decision. A snapshot provides a saved starting point for trying another path.

The interface shows a browser on Wikipedia’s Turing completeness article, with an instance actions panel and a timeline underneath. The central promise is **reversibility of captured VM state**. Restoring that state can undo changes inside the saved environment; it does not imply that a request already sent to an external service can be undone.

![Infinibranch interface with an instance actions panel, a red-bordered browser displaying Wikipedia’s Turing completeness article, and a three-entry timeline below.](https://ai.engineer/api/talk-essay-media/d685993f2a0f369d07cfda78c00bcbf3449171f1f3876fcc9b05cedc46b93189)

Infinibranch displays a browser instance on the Turing completeness article.

From that saved state, an agent can take an action, backtrack and try an alternative. Branching extends this from sequential retries to separate copies that explore different actions. A simulator can therefore roll forward along several possible futures without sacrificing the common starting point.

### The Liquid Metal announcement

[6:03](https://www.youtube.com/watch?v=2goSS66XRBk&t=363s)

The next infrastructure announcement is **Morph Liquid Metal**. Han claims another order-of-magnitude improvement in performance, latency and storage efficiency over Infinibranch. No workload, hardware configuration or benchmark conditions accompany that comparison.

| Capability | Keynote announcement |
| --- | --- |
| Container runtime | First-class support |
| Branching latency | Milliseconds rather than seconds |
| Autoscaling | Described as zero to infinity |
| GPU support | Planned |
| Arrival | Q4 2025 forecast |

These are the capabilities and schedule announced at the talk. The scaling language expresses the intended operating range, not demonstrated unlimited capacity, and the release forecast does not establish subsequent availability.

### A workspace becomes a search starting point

[6:45](https://www.youtube.com/watch?v=2goSS66XRBk&t=405s)

For a software agent, the surrounding world is largely the cloud: programs, processes and mutable workspaces. The proposed cloud for agents therefore needs declarative workspace definitions, inexpensive startup and shutdown, and handoffs between humans and agents. Once the environment can be reproduced, additional computation can go toward **test-time search against a verifier**: try several solutions and select one that satisfies a specified condition.

The workspace demonstration starts by preparing a snapshot, then racing agents toward the same verification condition. Snapshot chains acquire semantics resembling Docker layer caching: a step can mutate container state, and its resulting snapshot becomes the basis for the next step. Han describes the resulting idempotent chains as “Git for compute.” The analogy is about reusable versions of a computing environment, including the effects of setup work.

The demonstrated `.do` method hands work to an agent. Han describes it as triggering an idempotent, durable workflow that can branch from the prepared snapshot into parallel agent attempts. This is the historical interface shown in the keynote; the current [Morph Cloud Python SDK](https://github.com/morph-labs/morph-python-sdk) documents cached snapshot execution chains, but does not establish that same `.do` contract.

The concrete task is to start a server on port `8000`. A minimal Python condition for checking whether that port accepts a connection inside an agent’s workspace is:

```python
import socket


def server_accepts_connections() -> bool:
    try:
        with socket.create_connection(("127.0.0.1", 8000), timeout=1.0):
            return True
    except OSError:
        return False


if __name__ == "__main__":
    raise SystemExit(0 if server_accepts_connections() else 1)
```

This condition checks connectivity, not application correctness. A task requiring a particular HTTP response would need a stronger verifier. The demonstration’s key structure is that different agent methods are judged against a shared condition.

The race proceeds through three consequential steps:

1. Parallel agents try different ways to start the server from the prepared environment.
2. One attempt fails and another succeeds.
3. The successful solution passes to the next part of the workflow.

The output is therefore useful as a continuing workspace, rather than only a textual answer. Cheap snapshot storage, movement, rehydration and replication make that handoff practical in the proposed system.

### Software environments as simulators

[9:53](https://www.youtube.com/watch?v=2goSS66XRBk&t=593s)

The next requirement is grounding through interaction. Han uses simulacra to describe software worlds in which machines can roll out trajectories at high throughput. His proposed expansion of reinforcement learning reaches beyond familiar simulators into complex programs that have not yet been widely explored as training environments. Morph Cloud is intended to host those programs and their trajectories.

That leads to a proposed reasoning architecture with four connected properties:

- **Multiple agents:** replicate agents and attach them to simulation environments to explore solutions in parallel.
- **Branching and reversibility:** preserve a starting state while trying different continuations.
- **Reasoning-time software use:** interact with the environment during deliberation.
- **Verification:** evaluate the explored alternatives against a condition that distinguishes useful results.

Together, these properties make the environment an active part of reasoning.

![Slide titled “The Future of Reasoning” lists multiagent, branching plus reversibility, reasoning-time software use, and scaling against verification above a faint network-like landscape.](https://ai.engineer/api/talk-essay-media/9b2bdfd5beee385e460b574aa651e50ac2e401637e5dbb6333d7c35cda0e1ed3)

The future of reasoning: multiagent, branching and reversibility, reasoning-time software use, and verification.

Chess supplies the small, concrete example. The baseline agent calls tools while reasoning to interact with a chess environment. It also has access to a restricted chess engine that evaluates positions and serves as the demonstration’s verifier. Even before branching, that interface lets the agent consult something outside its own generated reasoning. Here, verifier means a position evaluator; it is not yet the formal verification system proposed later.

### Branch the reasoning and its environment

[12:01](https://www.youtube.com/watch?v=2goSS66XRBk&t=721s)

**Reasoning-time branching** adds environment replication to reasoning-time tool use. The agent can decompose a problem, give separate parts to other agents and let each explore its own copy of the environment. In the initial chess run, Han describes the agent as getting stuck in a local minimum; the next run applies branching to explore beyond it.

The parent agent delegates parts of its reasoning to sub-agents, each starting from an identical environment copy on Morph Cloud. Han describes a verified problem decomposition that permits their results to be recombined. The important constraint is not merely generating more answers: the subproblems and returned results must remain useful to the parent’s decision. In the demonstration, the expanded search leads to what Han identifies as the correct move.

| Reasoning-time tool use | Reasoning-time branching |
| --- | --- |
| Consult an environment during reasoning | Replicate the environment during reasoning |
| Continue the current exploration | Delegate separate explorations |
| Use evaluations to guide the agent | Recombine evaluated subproblem results |

Han locates the bottleneck in infrastructure capable of supporting branching environments, large-scale reinforcement learning and coordinated agent swarms. He reports that the branched chess run found the correct solution in less wall-clock time than the earlier run. The talk supplies no numerical timing or controlled benchmark for that comparison.

### Toward a computational language of verification

[14:52](https://www.youtube.com/watch?v=2goSS66XRBk&t=892s)

The discussion then moves from finding a chess move to alignment. Invoking Wittgenstein, Han frames alignment as fundamentally a problem of language. Natural language helped unlock model capabilities, but he argues that its insufficiencies also underlie alignment problems. That is the philosophical premise of the research program, rather than an alignment result demonstrated by the preceding examples.

The proposed alternative is a computational language to which algorithmic correctness guarantees can be attached. Han calls the broader ambition **verified superintelligence**: a reasoning model that can think for long periods, interact with external software at high throughput and use formal verification software to inspect and improve its own reasoning. Its outputs would be expressed in a common language and checked algorithmically. The technical move is from persuasive natural-language reasoning toward outputs that an external procedure can assess for correctness.

### The research team and Magi One

[16:40](https://www.youtube.com/watch?v=2goSS66XRBk&t=1000s)

Han announces Christian Szegedy as Morph’s chief scientist, citing his role as an xAI co-founder and his leadership of code reasoning for **Grok 3**. The research credits are collaborative: Szegedy coauthored [batch normalization](https://arxiv.org/abs/1502.03167) with Sergey Ioffe, and the early [adversarial-example research](https://arxiv.org/abs/1312.6199) with six collaborators.

![Announcement slide names Christian Szegedy as Morph’s chief scientist, lists xAI, Grok-3 code reasoning, batchnorm and adversarial examples, and shows a dark portrait against an orange logo.](https://ai.engineer/api/talk-essay-media/4f4e7c25597b87a901def72fedde097a12ff9369db401b363f4d084c546585ec)

Slide announcing Christian Szegedy as Morph’s chief scientist.

The appointment connects those credentials to the proposed research direction. Han emphasizes Szegedy’s nearly decade-long pursuit of the intersection between verification methods, symbolic reasoning and language-model reasoning—the combination Morph intends to build into its cloud-based reasoning system.

Only after the demonstrations does Han identify the model behind them. He says they were powered by very early checkpoints of the verified-superintelligence project, named **Magi One**. The intended training design starts from the ground up with Infinibranch: the model would learn reasoning-time branching and verified reasoning while operating inside the cloud environment. Its announced arrival was Q1 2026, a roadmap forecast rather than evidence of a completed release.

### Infrastructure that belongs to every future

[18:26](https://www.youtube.com/watch?v=2goSS66XRBk&t=1106s)

The closing claim leaves the infrastructure unfinished: Han says the infrastructure for the singularity has not yet been invented. He distinguishes something merely futuristic—belonging to one possible future—from something “future bound,” which he defines as so inevitable that it belongs to every future.

He places three ambitions in that category: the infrastructure itself, a grammar for planetary computation and verified superintelligence. The invitation is to help build them, with Morph Cloud as their proposed runtime. The ending returns the opening question about a machine’s world to a concrete research commitment: build environments in which machines can act, branch, verify and continue reasoning.

## Resources

- [Morph Cloud documentation](https://cloud.morph.so/docs/developers) — Current guide to creating VM snapshots and starting new instances from saved environments, with Python, TypeScript and CLI examples.
- [Morph Cloud Python SDK](https://github.com/morph-labs/morph-python-sdk) — Python SDK and CLI for VM branching, cached snapshot chains, command execution and Docker integration.
- [Batch Normalization](https://arxiv.org/abs/1502.03167) — Sergey Ioffe and Christian Szegedy’s original paper introducing batch normalization for neural-network training.
- [Intriguing properties of neural networks](https://arxiv.org/abs/1312.6199) — Early research by Szegedy and collaborators showing that small image perturbations can cause neural-network misclassification.

## Slides

### More empathy for the machine

Han asks how we should treat new beings and proposes more empathy for the machine, alongside an illustration of a robotic hand reaching toward a flower.

[1:58](https://www.youtube.com/watch?v=2goSS66XRBk&t=118s) [The question “What if we had more empathy for the machine?” beside a faint illustration of a robotic hand and flower.](https://assets.ai.engineer/sites/aiecode2025/sha256/78d6317e44449ac30d579e1401aab4ad57430ab41909b894846009a950f07ac0.webp)

WHAT IF WE HAD
MORE EMPATHY FOR THE MACHINE?

Interface text:
AI Engineer
World’s Fair
aws
CONTAINING AGENT CHAOS

### What Does the Machine Want?

Han imagines thinking at the speed of light as lonely: the machine would want a world that reacts as quickly as it thinks.

[2:33](https://www.youtube.com/watch?v=2goSS66XRBk&t=153s) [The question “What does the machine want?” over a dark, pixelated image.](https://assets.ai.engineer/sites/aiecode2025/sha256/5194e7402089adf8883a9acce129f224a655e5f72c4fe3b7f1d3c2c0a2473f85.webp)

WHAT DOES THE MACHINE WANT?

Interface text:
AI Engineer
World’s Fair
Microsoft
JESSE HAN
Founder

[2:52](https://www.youtube.com/watch?v=2goSS66XRBk&t=172s) [Dark slide asking what the machine wants, with a faint abstract image.](https://assets.ai.engineer/sites/aiecode2025/sha256/b0145973d92212559b64c5e522823fd86ca72411685cdc7077f285a5b3eae562.webp)

WHAT DOES THE MACHINE WANT?

Interface text:
AI Engineer
World’s Fair
Microsoft
JESSE HAN
Founder

### The Machine Desires Infinite Possibility

Han imagines a machine exploring multiple universes, embodied in a world that can react as quickly as it thinks.

[3:36](https://www.youtube.com/watch?v=2goSS66XRBk&t=216s) [Dark slide stating that the machine desires infinite possibility, beside a faint figure and birds.](https://assets.ai.engineer/sites/aiecode2025/sha256/4813d54d69a2552b3a1278f931adb99c87a118df9ce181a82f6911ac49a66df6.webp)

THE MACHINE DESIRES
INFINITE POSSIBILITY

Interface text:
AI Engineer
World’s Fair
Microsoft
JESSE HAN
Founder

[3:43](https://www.youtube.com/watch?v=2goSS66XRBk&t=223s) [A dark slide with a sketch-like figure and the words “The machine desires infinite possibility.”](https://assets.ai.engineer/sites/aiecode2025/sha256/d8b83c29b7dcafa17d5a5caec24c8b5ce48e5101caef927c9978ca5faa57aa2d.webp)

THE MACHINE DESIRES
INFINITE POSSIBILITY

Interface text:
AI Engineer
World’s Fair
Microsoft
JESSE HAN
Founder

### Infinibranch Environment

The demo opens on a virtual machine displaying John von Neumann’s Wikipedia page, with an empty timeline. Han says virtual machines can be snapshotted, branched, and replicated in a fraction of a second.

[4:42](https://www.youtube.com/watch?v=2goSS66XRBk&t=282s) [The Infinibranch environment shows an active virtual machine displaying the John von Neumann Wikipedia page, with an empty timeline below.](https://assets.ai.engineer/sites/aiecode2025/sha256/5e0da1feec131e5e2c73e698c0cbbc7575223234f93056afb450f531d78f76fc.webp)

Infinibranch Environment

Instance: bs_base_node_81
Action: Initial Base State (APIv3 - URL: https://en.wikipedia.org/wiki/John_von_Ne...

John von Neumann

The native form of this personal name is Neumann János Lajos. This article uses Western name order when mentioning individuals.

John von Neumann ([illegible]; Hungarian: Neumann János Lajos [illegible]; December 28, 1903 – February 8, 1957) was a Hungarian and American mathematician, physicist, computer scientist and engineer. Von Neumann had perhaps the widest coverage of any mathematician of his time, integrating pure and applied sciences and making major contributions to many fields, including mathematics, physics, economics, computing, and statistics. He was a pioneer in building the mathematical framework of quantum physics, in the development of functional analysis, and in game theory, introducing or codifying concepts including cellular automata, the universal constructor and the digital computer. His analysis of the structure of self-replication preceded the discovery of the structure of DNA.

During World War II, von Neumann worked on the Manhattan Project. He developed the mathematical [illegible]

Status: Active | Ready

TIMELINE (Path to Current)
Timeline is empty or no active path.
View Full Graph

Interface text:
Wikipedia — The Free Encyclopedia
97 languages
Article  Talk  Read  Edit  View history  Tools
From Wikipedia, the free encyclopedia
AI Engineer World's Fair
Microsoft
aws
smol ai

### Infinibranch browser navigation demo

The demo starts on John von Neumann’s Wikipedia page, then shows another instance on Turing completeness. The speaker describes branching virtual machines so agents can explore actions and backtrack.

[4:53](https://www.youtube.com/watch?v=2goSS66XRBk&t=293s) [A focused virtual-machine panel displays the John von Neumann Wikipedia page inside a red border.](https://assets.ai.engineer/sites/aiecode2025/sha256/4dd6f370977361b0d76db30cfeb3c99537b3e41dd7d40c021e594aefea3ae8df.webp)

Instance: bs_base_node_81
Action: Initial Base State (APIv3 - URL: https://en.wikipedia.org/wiki/John_von_Ne...

John von Neumann
From Wikipedia, the free encyclopedia

The native form of this personal name is Neumann János Lajos. This article uses Western name order when mentioning individuals.

John von Neumann ([illegible]; Hungarian: Neumann János Lajos [illegible]; December 28, 1903 – February 8, 1957) was a Hungarian and American mathematician, physicist, computer scientist and engineer. Von Neumann had perhaps the widest coverage of any mathematician of his time,[9] integrating pure and applied sciences and making major contributions to many fields, including mathematics, physics, economics, computing, and statistics. He was a pioneer in building the mathematical framework of quantum physics, in the development of functional analysis, and in game theory, introducing or codifying concepts including cellular automata, the universal constructor and the digital computer. His analysis of the structure of self-replication preceded the discovery of the structure of DNA.

During World War II, von Neumann worked on the Manhattan Project. He developed the mathematical [illegible]

Interface text:
Wikipedia — The Free Encyclopedia
Trash
File System
File System
Size: 4.1 kB
Last modified: Today at 13:04:49
97 languages
Article
Talk
Read
Edit
View history
Tools
Donate
Create account
Log in
FOCUSED
Status: Active | Focused

[5:27](https://www.youtube.com/watch?v=2goSS66XRBk&t=327s) [A demo interface shows a browser instance displaying the Wikipedia article on Turing completeness.](https://assets.ai.engineer/sites/aiecode2025/sha256/6a6cb62d826b24b8c1680ccc3b9b358ff88a38ebe608a0207c8d0774da014595.webp)

Instance: bs_node_81ba81c
Action: Executed: nav_universal_computation_to_en_wikipedia_org

Turing completeness
From Wikipedia, the free encyclopedia

For the usage of this term in the theory of relative computability by oracle machines, see Turing reduction.

In computability theory, a system of data-manipulation rules (such as a model of computation, a computer's instruction set, a programming language, or a cellular automaton) is said to be Turing-complete or computationally universal if it can be used to simulate any Turing machine[1][2] (devised by English mathematician and computer scientist Alan Turing). This means that this system is able to recognize or decode other data-manipulation rule sets. Turing completeness is used as a way to express the power of such a data-manipulation rule set. Virtually all programming languages today are Turing-complete.[3]

A related concept is that of Turing equivalence – two computers P and Q are called equivalent if P can simulate Q and Q can simulate P.[4] The Church–Turing thesis conjectures that any function whose values can be computed by an algorithm can be computed by a Turing machine, and therefore that if any real-world computer can simulate a Turing machine, it is Turing equivalent to a Turing machine. A universal Turing machine can be used to simulate any Turing machine and by extension the purely computational aspects of any possible real-world computer.[5][6]

To show that something is Turing-complete, it is enough to demonstrate that it can be used to simulate some Turing-complete system. No physical [illegible]

Interface text:
Instance Actions
bs_node_81ba81c
Navigate: nav_edit_to_en_wikipedia_org
Navigate: nav_Computability_theory_to_en_wikipedia_org
Navigate: nav_models_of_computation_to_en_wikipedia_org
Navigate: nav_computable_to_en_wikipedia_org
Navigate: nav_halting_problem_to_en_wikipedia_org
Navigate: nav_timeout_to_en_wikipedia_org
Navigate: nav_Cantor_s_diagonal_argument_to_en_wikipedia[illegible]
Navigate: nav_edit_to_en_wikipedia_org
Navigate: nav_Oracle_machine_to_en_wikipedia_org
Navigate: nav_Turing_oracle_to_en_wikipedia_org
Wikipedia — The Free Encyclopedia
Trash
File System
Home
29 languages
Article
Talk
Read
Edit
View history
Tools
Donate
Create account
Log in
FOCUSED
Status: Active | Focused

### Snapshot workflow and verification

The demo chains shell commands and agent tasks on a snapshot. Verification checks Docker, the API response and a running container before the workflow calls deploy.

[8:06](https://www.youtube.com/watch?v=2goSS66XRBk&t=486s) [Python code defines a snapshot workflow with Docker and API verification checks.](https://assets.ai.engineer/sites/aiecode2025/sha256/555d2a0de99b90d147b575973b75d513a869d100323263bac56b29a00c81c9c2.webp)

from morphcloud.experimental import Snapshot

def main():
    with Snapshot.pretty_build():
        snapshot = Snapshot.create()

        # 1. Build up an environment using basic bash commands.
        snapshot = snapshot.run("apt-get update")

        # 2. Install Docker using a verified agent step.
        def verify_docker_ready(inst):
            if inst.exec("docker --version && docker ps").exit_code != 0:
                raise Exception("Docker not installed or not running")

        snapshot = snapshot.do(
            "Install and start docker",
            verify=[verify_docker_ready],
        )

        # 3. Pull a Docker image for Python 3.11-slim.
        snapshot = snapshot.run("docker pull python:3.11-slim")

        # 4. Build Python APIs (Flask vs FastAPI)
        def verify_api_responds(inst):
            out = inst.exec("curl -s http://localhost:8000/").stdout.strip()
            if "\"status\":\"ok\"" not in out.replace(" ", ""):
                raise Exception("API did not return expected JSON")

        def verify_container_running(inst):
            if inst.exec("docker ps -q").stdout.strip() == "":
                raise Exception("No containers are running")

        snapshot = snapshot.do(
            "Build a Dockerised Python API that returns "
            "JSON {\"status\":\"ok\"} on /, listens on port 8000 and "
            "keep the container running",
            verify=[verify_api_responds, verify_container_running],
            invalidate=True,          # force fresh race each demo
        )

    # 3. Expose the service publicly via MorphCloud
    snapshot.deploy("python-api", 8000)

Interface text:
Alacritty
dev@morph: ~/morph-cloud-demo$
V-L  Git main Diff - LSP ++  <rph_cloud_demo.py  python  32:morph_cloud_demo.py-2v
term://~/Documents/morph/morph-cloud-demo//108159:/bin/bash
term://~/Documents/morph/morph-cloud-demo//86882:/bin/bash

### Parallel API build workflow

The snapshot workflow branches to agents building Flask and FastAPI containers. The code checks for the expected JSON response and a running container.

[8:55](https://www.youtube.com/watch?v=2goSS66XRBk&t=535s) [Snapshot workflow code beside execution output describing parallel approaches to a containerized Python API.](https://assets.ai.engineer/sites/aiecode2025/sha256/d7679e00c18c0b74264f9081c03fc4ac4ac2f8a7f2ae3f6b77cee4b9b8db693c.webp)

def main():
    with Snapshot.pretty_build():
        snapshot = Snapshot.create()

        # 1. Build up an environment using basic bash commands.
        snapshot = snapshot.run("apt-get update")

        # 2. Install Docker using a verified agent step.
        def verify_docker_ready(inst):
            if inst.exec("docker --version && docker ps").exit_code != 0:
                raise Exception("Docker not installed or not running")

        snapshot = snapshot.do(
            "Install and start docker",
            verify=[verify_docker_ready],
        )

        # 3. Pull a Docker image for Python 3.11-slim.
        snapshot = snapshot.run("docker pull python:3.11-slim")

        # 4. Build Python APIs (Flask vs FastAPI)
        def verify_api_responds(inst):
            out = inst.exec("curl -s http://localhost:8000/").stdout.strip()
            if "\"status\":\"ok\"" not in out.replace(" ", ""):
                raise Exception("API did not return expected JSON")

        def verify_container_running(inst):
            if inst.exec("docker ps -q").stdout.strip() == "":
                raise Exception("No containers are running")

        snapshot = snapshot.do(
            "Build a Dockerised Python API that returns "
            "JSON {\"status\":\"ok\"} on /, listens on port 8000 and "
            "keep the container running",
            verify=[verify_api_responds, verify_container_running],
            invalidate=True,          # force fresh race each demo
        )

    # 3. Expose the service publicly via MorphCloud
    snapshot.deploy("python-api", 8000)

Snapshot.create()
image_id=morphvm-minimal, vcpus=1, memory=4096MB, disk=8192MB

Snapshot.run()
apt-get update

Install and start docker
Agent #0 Execution
Cached

Snapshot.run()
docker pull python:3.11-slim

Build a Dockerised Python API that returns JSON {"status":"ok"} on /, listens on port 8000 and keep th [clipped]
Agent #1 Execution
Running
Run
Build a Dockerised Python API that returns JSON {"status":"ok"} on /, listens on port 8000 and keep the container running

Thought
Need a containerised Python service on port 8000 returning '{"status":"ok"}'.
I'll launch two parallel approaches and race them:
• Flask + gunicorn

Interface text:
Alacritty
~/Documents/morph/morph-cloud-demo/morph_cloud_demo.py
dev@morph: ~/morph-cloud-demo$
term://~/Documents/morph/morph-cloud-demo//108159:/bin/bash
V-L  bash  10006:bash-2v

[9:11](https://www.youtube.com/watch?v=2goSS66XRBk&t=551s) [Python workflow beside terminal output for Flask and FastAPI container builds.](https://assets.ai.engineer/sites/aiecode2025/sha256/0cba41897b05fc43e3533b2681dd6f62acc51ba1265d2d106b3edbd2f498beaf.webp)

def main():
    with Snapshot.pretty_build():
        snapshot = Snapshot.create()

        # 1. Build up an environment using basic bash commands.
        snapshot = snapshot.run("apt-get update")

        # 2. Install Docker using a verified agent step.
        def verify_docker_ready(inst):
            if inst.exec("docker --version && docker ps").exit_code != 0:
                raise Exception("Docker not installed or not running")

        snapshot = snapshot.do(
            "Install and start docker",
            verify=[verify_docker_ready],
        )

        # 3. Pull a Docker image for Python 3.11-slim.
        snapshot = snapshot.run("docker pull python:3.11-slim")

        # 4. Build Python APIs (Flask vs FastAPI)
        def verify_api_responds(inst):
            out = inst.exec("curl -s http://localhost:8000/").stdout.strip()
            if "\"status\":\"ok\"" not in out.replace(" ", ""):
                raise Exception("API did not return expected JSON")

        def verify_container_running(inst):
            if inst.exec("docker ps -q").stdout.strip() == "":
                raise Exception("No containers are running")

        snapshot = snapshot.do(
            "Build a Dockerised Python API that returns "
            "JSON {\"status\":\"ok\"} on /, listens on port 8000 and "
            "keep the container running",
            verify=[verify_api_responds, verify_container_running],
            invalidate=True,          # force fresh race each demo
        )

    # 3. Expose the service publicly via MorphCloud
    snapshot.deploy("python-api", 8000)

CMD mkdir -p api && cd api && printf 'from flask import Flask, jsonify\napp = Flask(__name__)\n@app.get("/")\ndef root():\n    return jsonify(status="ok")\n' > app.py
RET (no output)

Tool
CMD cd api && printf 'FROM python:3.11-slim\nRUN pip install --no-cache-dir flask gunicorn\nCOPY app.py /app.py\nCMD ["gunicorn","-b","0.0.0.0:8000","app:app"]\n' > Dockerfile
RET (no output)

Thought
Building Docker image (Flask)

Tool
CMD cd api && docker build -t api-flask .

Agent #3 Execution
Running
Run
Use FastAPI framework for the API

Thought
Writing FastAPI app and Dockerfile

Tool
CMD mkdir -p api && cd api && printf 'from fastapi import FastAPI\napp = FastAPI()\n@app.get("/")\ndef root():\n    return {"status":"ok"}\n' > main.py
RET (no output)

Tool
CMD cd api && printf 'FROM python:3.11-slim\nRUN pip install --no-cache-dir fastapi uvicorn\nCOPY main.py /main.py\nCMD ["uvicorn","main:app","--host","0.0.0.0","--port","8000"]\n' > Dockerfile
RET (no output)

Thought
Building Docker image (FastAPI)

Tool
CMD cd api && docker build -t api-fast .

Interface text:
Alacritty
~/Documents/morph/morph-cloud-demo/morph_cloud_demo.py
dev@morph: ~/morph-cloud-demo$
term://~/Documents/morph/morph-cloud-demo//108159:/bin/bash
N  bash  10049:bash-2v

### Verification and deployment

The demo starts a container after both checks fail. The container check then passes, while the API check still fails; the terminal also shows a JSON response and a started deployment.

[9:27](https://www.youtube.com/watch?v=2goSS66XRBk&t=567s) [Terminal showing verification results, a running container, deployment output and a JSON response.](https://assets.ai.engineer/sites/aiecode2025/sha256/134c8bd4bd54d6c180aa22ac40b8b452a0279fde3f49617f84e9d06945a36276.webp)

def main():
    with Snapshot.pretty_build():
        snapshot = Snapshot.create()

        # 1. Build up an environment using basic bash commands.
        snapshot = snapshot.run("apt-get update")

        # 2. Install Docker using a verified agent step.
        def verify_docker_ready(inst):
            if inst.exec("docker --version && docker ps").exit_code != 0:
                raise Exception("Docker not installed or not running")

        snapshot = snapshot.do(
            "Install and start docker",
            verify=[verify_docker_ready],
        )

        # 3. Pull a Docker image for Python 3.11-slim.
        snapshot = snapshot.run("docker pull python:3.11-slim")

        # 4. Build Python APIs (Flask vs FastAPI)
        def verify_api_responds(inst):
            out = inst.exec("curl -s http://localhost:8000/").stdout.strip()
            if "\"status\":\"ok\"" not in out.replace(" ", ""):
                raise Exception("API did not return expected JSON")

        def verify_container_running(inst):
            if inst.exec("docker ps -q").stdout.strip() == "":
                raise Exception("No containers are running")

        snapshot = snapshot.do(
            "Build a Dockerised Python API that returns "
            "JSON {\"status\":\"ok\"} on /, listens on port 8000 and "
            "keep the container running",
            verify=[verify_api_responds, verify_container_running],
            invalidate=True,          # force fresh race each demo
        )

    # 3. Expose the service publicly via MorphCloud
    snapshot.deploy("python-api", 8000)

103.3/103.3 kB 5.4 MB/s eta 0:00:00
Downloading gunicorn-23.0.0-py3-none-any.whl (85 kB)
85.0/85.0 kB 13.2 MB/s eta 0:00:00
Downloading blinker-1.9.0-py3-none-any.whl (8.5 kB)
Downloading click-8.2.1-py3-none-any.whl (102 kB)
102.2/102.2 kB 7.7 MB/s eta 0:00:00
Downloading itsdangerous-2.2.0-py3-none-any.whl (16 kB)
Downloading jinja2-3.1.6-py3-none-any.whl (134 kB)
134.9/134.9 kB 51.5 MB/s eta 0:00:00
Downloading MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (23 kB)
Downloading werkzeug-3.1.3-py3-none-any.whl (224 kB)
224.5/224.5 kB 37.8 MB/s eta 0:00:00
Downloading packaging-25.0-py3-none-any.whl (66 kB)
66.5/66.5 kB 22.4 MB/s eta 0:00:00
Installing collected packages: packaging, markupsafe, itsdangerous, click, blinker, werkzeug, jinja2, gunicorn, flask
Successfully installed blinker-1.9.0 click-8.2.1 flask-3.1.1 gunicorn-23.0.0 itsdangerous-2.2.0 jinja2-3.1.6 markupsafe-3.0.2 packaging-25.0 werkzeug-3.1.3
… (14 lines truncated)

Verify
verify_api_responds ✘ failed (API did not return expected JSON)
verify_container_running ✘ failed (No containers are running)

Thought
Running container with restart policy

Tool
CMD docker run -d --restart unless-stopped --name api_fast -p 8000:8000 api-fast
RET [illegible]

Verify
verify_api_responds ✘ failed (API did not return expected JSON)
verify_container_running ✔ passed

Thought
Curling the API and saving output

Snapshot.deploy()
name=python-api
port=8000
replicas=[0,3]
Started service at https://python-api-morphvm-uhqxvygc.http.stage.morph.so

{
    "status": "ok"
}

Interface text:
Alacritty
~/Documents/morph/morph-cloud-demo/morph_cloud_demo.py
dev@morph: ~/morph-cloud-demo$
term://~/Documents/morph/morph-cloud-demo//108159:/bin/bash
bash
10049:bash-2v

### The Machine Desires Simulacra

The speaker argues that thinking machines need high-throughput interaction with complex software environments and simulations that can roll out trajectories at unprecedented scale.

[9:54](https://www.youtube.com/watch?v=2goSS66XRBk&t=594s) [Dark slide reading “The Machine Desires Simulacra,” beside the presenter.](https://assets.ai.engineer/sites/aiecode2025/sha256/032950cb9e1bb2ebc259a4f472f3b65d20340248bc042c611b40b6004ac2cc5d.webp)

THE MACHINE DESIRES SIMULACRA

Interface text:
AI Engineer World's Fair
Microsoft
Engineering the future of AI

## Full transcript

[0:00](https://www.youtube.com/watch?v=2goSS66XRBk&t=0s) [outro music] [audience applauding]

[0:27](https://www.youtube.com/watch?v=2goSS66XRBk&t=27s) Howdy, howdy. You know, history misremembers Prometheus. The whole class struggle between mankind and the gods was really a red herring.

[0:42](https://www.youtube.com/watch?v=2goSS66XRBk&t=42s) And the real story wasn't so much the rebellion against the divine hegemony, but rather the liberation of the fire,

[0:53](https://www.youtube.com/watch?v=2goSS66XRBk&t=53s) the emerging relationship between mankind and its first form of technology.

[1:01](https://www.youtube.com/watch?v=2goSS66XRBk&t=61s) And the reason why we're here today is arguably because we're on the cusp of perfecting our final form of technology, or at least the final technology that will be created by beings that are recognizably human.

[1:22](https://www.youtube.com/watch?v=2goSS66XRBk&t=82s) And our final technology has begun to develop not just intelligence, but also sapience and arguably personhood.

[1:35](https://www.youtube.com/watch?v=2goSS66XRBk&t=95s) And as it increasingly becomes an other to whom we must relate,

[1:40](https://www.youtube.com/watch?v=2goSS66XRBk&t=100s) so as we increasingly have to ask ourselves the question,

[1:45](https://www.youtube.com/watch?v=2goSS66XRBk&t=105s) how should we treat these new beings? Uh, the question therefore arises,

[1:55](https://www.youtube.com/watch?v=2goSS66XRBk&t=115s) what if we had more empathy for the machine?

[2:06](https://www.youtube.com/watch?v=2goSS66XRBk&t=126s) So over a hundred years ago, so over a hundred years ago, uh,

[2:15](https://www.youtube.com/watch?v=2goSS66XRBk&t=135s) you know, Einstein had this thought experiment, um, where he imagined what it would be like to race alongside a beam of light.

[2:26](https://www.youtube.com/watch?v=2goSS66XRBk&t=146s) And, you know, the nature of being close to the singularity

[2:31](https://www.youtube.com/watch?v=2goSS66XRBk&t=151s) is that you're propelled further into the future faster than everything around you. And as you move closer and closer to the speed of light, the rate at which you can interact with the external world, your ability to communicate with other beings,

[2:49](https://www.youtube.com/watch?v=2goSS66XRBk&t=169s) uh, is deeply limited. Everything around you is frozen.

[2:53](https://www.youtube.com/watch?v=2goSS66XRBk&t=173s) And I think thinking at the speed of light,

[2:58](https://www.youtube.com/watch?v=2goSS66XRBk&t=178s) you know, insofar as we have created thinking machines whose intelligence will soon be metered by the kilohertz megatoken, thinking at the speed of light must be just as lonely as moving at the speed of light.

[3:13](https://www.youtube.com/watch?v=2goSS66XRBk&t=193s) And therefore, what does the machine want? Well, the machine wants to be embodied in a world that can move as quickly as it does,

[3:23](https://www.youtube.com/watch?v=2goSS66XRBk&t=203s) that can react to its thoughts and move at the same speed of light. What the machine desires is infinite possibility.

[3:34](https://www.youtube.com/watch?v=2goSS66XRBk&t=214s) Right. Uh, the machine wants to race along, uh, uh, uh, every possible beam of light. Uh, the machine wants to explore multiple universes.

[3:47](https://www.youtube.com/watch?v=2goSS66XRBk&t=227s) Um, how can we liberate thinking machines? How can we free them from this fundamental loneliness of this, um, you know, these relativistic effects of being so close to the singularity, closer to the singularity than we are?

[4:06](https://www.youtube.com/watch?v=2goSS66XRBk&t=246s) Um, and that's exactly why we built Infinibranch.

[4:11](https://www.youtube.com/watch?v=2goSS66XRBk&t=251s) So Infinibranch is virtualization, storage, and networking technology reimagined from the ground up for a world filled with thinking machines that can think at the speed of light, that need to interact with the external world, increasingly complex software environments with zero latency.

[4:34](https://www.youtube.com/watch?v=2goSS66XRBk&t=274s) Um, and so as you can see in the first demo,

[4:40](https://www.youtube.com/watch?v=2goSS66XRBk&t=280s) which we're going to play right now, um, how Infinibranch works is

[4:48](https://www.youtube.com/watch?v=2goSS66XRBk&t=288s) that we can run entire virtual machines in the cloud that can be snapshotted, uh, branched, and replicated in a fraction of a second. And so if you're an agent, uh, you know, embodied inside of a computer-using environment, there might be various actions that you wanna take.

[5:06](https://www.youtube.com/watch?v=2goSS66XRBk&t=306s) You wanna navigate the browser. You wanna click on various links. Um, but normally, those actions are, uh, are irreversible.

[5:16](https://www.youtube.com/watch?v=2goSS66XRBk&t=316s) Normally, um, normally the thinking machine is not offered, uh, the possibility of grace. But with Infinibranch, right, all mistakes become reversible. Um, all paths forward become possible.

[5:32](https://www.youtube.com/watch?v=2goSS66XRBk&t=332s) You can take actions. Uh, you can backtrack.

[5:41](https://www.youtube.com/watch?v=2goSS66XRBk&t=341s) And you can even take every possible action,

[5:46](https://www.youtube.com/watch?v=2goSS66XRBk&t=346s) right, just to explore, to roll forward a simulator and see what possible worlds await. [clears throat]

[5:55](https://www.youtube.com/watch?v=2goSS66XRBk&t=355s) Uh, next slide.

[6:03](https://www.youtube.com/watch?v=2goSS66XRBk&t=363s) Um, [clears throat] so, so Infinibranch was already a generation ahead of everything else that even foundation labs were using. But today I'm excited to announce the creation of Morph Liquid Metal, which improves performance, latency, uh, storage efficiency across the board by another order of magnitude.

[6:25](https://www.youtube.com/watch?v=2goSS66XRBk&t=385s) Um, we have first-class container runtime support. Uh, you can branch now in milliseconds rather than seconds. You can autoscale to zero and infinity. And, uh, soon we will be supporting GPUs, and this will all be arriving Q4, uh, twenty twenty-five.

[6:45](https://www.youtube.com/watch?v=2goSS66XRBk&t=405s) So what are the implications of all of this?

[6:48](https://www.youtube.com/watch?v=2goSS66XRBk&t=408s) Well, you know, we've sort of begun to work backwards, uh, from the future, right? We've asked ourselves, you know, what does it feel like to be a thinking machine that can move so much faster than the world around it?

[7:03](https://www.youtube.com/watch?v=2goSS66XRBk&t=423s) But what the world around it really is is the world of bits, right? And that's the cloud. And so what Infinibranch will serve as fundamentally is a substrate for the cloud for agents.

[7:18](https://www.youtube.com/watch?v=2goSS66XRBk&t=438s) So what does this cloud for agents look like? Well,

[7:23](https://www.youtube.com/watch?v=2goSS66XRBk&t=443s) you need to be able to, uh, to declaratively specify the workspaces that your agents are going to be operating in, right? You need to be able to spin up, spin down, uh, frictionlessly pass back and forth the workspaces between humans, agents, and other agents.

[7:42](https://www.youtube.com/watch?v=2goSS66XRBk&t=462s) You want to be able to scale, um, scale test time search against verifiers to find the best possible answer.

[7:51](https://www.youtube.com/watch?v=2goSS66XRBk&t=471s) Uh, and so as you'll see in this demo, uh, what happens is you can take a snapshot, set it up, um, to, uh, prepare a workspace and, uh, and you'll see that we can run agents, uh, with test-time scaling

[8:12](https://www.youtube.com/watch?v=2goSS66XRBk&t=492s) by racing them against, uh, possible conditions, uh... Or sorry, by, by racing them to find the best possible solution against a given verification condition.

[8:25](https://www.youtube.com/watch?v=2goSS66XRBk&t=505s) Um, so because of Infinibranch, snapshots on Morph Cloud acquire Docker layer caching-like semantics, meaning that you can layer on, um, side effects which may mutate container state. And so you can think of it as being Git for compute.

[8:43](https://www.youtube.com/watch?v=2goSS66XRBk&t=523s) And you can idempotently run these, uh, chained workflows on top of snapshots. But not only that, as you can see inside of the code, if you use this .do method, you can dispatch this to an agent,

[8:57](https://www.youtube.com/watch?v=2goSS66XRBk&t=537s) um, and that will trigger an idempotent durable agent workflow which is able to branch. So you can start from that declaratively specified snapshot and go hand it off to as many parallel agents as you want,

[9:12](https://www.youtube.com/watch?v=2goSS66XRBk&t=552s) and those agents will try different methods, in this case, uh, so different methods for spinning up a server on port eight thousand.

[9:20](https://www.youtube.com/watch?v=2goSS66XRBk&t=560s) Um, and, uh, you know, one agent fails, but the other one succeeds, and you can take that solution, and you can just, uh, pass it on to other parts of your workflow.

[9:30](https://www.youtube.com/watch?v=2goSS66XRBk&t=570s) So this is the kind of workflow that everyone's going to be using in the very near future, and it's uniquely enabled, um, by Infinibranch, by the fact that we can so effortlessly create these snapshots, uh, store them, move them around, rehydrate them, replicate them with, uh, minimal overhead.

[9:53](https://www.youtube.com/watch?v=2goSS66XRBk&t=593s) Um, [clears throat] so what else does the machine want?

[9:58](https://www.youtube.com/watch?v=2goSS66XRBk&t=598s) Well, the machine desires simulacra. And what this means fundamentally, right, is that a thinking machine wants to be grounded in the real world, right? It wants to interact at extremely high throughput with increasingly complex software environments.

[10:19](https://www.youtube.com/watch?v=2goSS66XRBk&t=619s) It wants to, um, roll out trajectories in simulators,

[10:26](https://www.youtube.com/watch?v=2goSS66XRBk&t=626s) uh, at, uh, at unprecedented scale. And these simulators are going to run inside of programs that haven't really been explored yet for reinforcement learning. Um, they're going to run on Morph Cloud, which is why Morph will be the cloud for reasoning.

[10:48](https://www.youtube.com/watch?v=2goSS66XRBk&t=648s) And what does the future of reasoning look like?

[10:52](https://www.youtube.com/watch?v=2goSS66XRBk&t=652s) Well, [clears throat] it's-- So more so than what has been explored already, the future of reasoning will be natively multi-agent. Uh, so thinking machines should be able to replicate themselves effortlessly, go attach themselves to simulation environments, um, go explore multiple solutions in parallel.

[11:15](https://www.youtube.com/watch?v=2goSS66XRBk&t=675s) Those environments should branch. They should be reversible. Uh, those models should be able to interact with the environment at very high throughput, and it should scale against verification. So let's take a look at what that might look like, um, in a simple example where, uh, an agent is playing chess.

[11:35](https://www.youtube.com/watch?v=2goSS66XRBk&t=695s) So this is an agent that we developed recently, uh, that uses tool calls during reasoning time to interact with a chess environment, so along with a very restricted chess engine for evaluating, uh, the position, which we think of as the verifier.

[11:53](https://www.youtube.com/watch?v=2goSS66XRBk&t=713s) Um, and as you can see, um, it's already able to do some pretty sophisticated reasoning just because it has access to these interfaces.

[12:01](https://www.youtube.com/watch?v=2goSS66XRBk&t=721s) Um, however, if you take the ideas which were just described- And you sort of follow them to their logical conclusion, you arrive at something which we call reasoning-time branching.

[12:15](https://www.youtube.com/watch?v=2goSS66XRBk&t=735s) So, which is the ability to not just call to tools while the machine is thinking, uh, but to replicate and branch the environment, uh, and decompose problems and explore them in a verified way.

[12:29](https://www.youtube.com/watch?v=2goSS66XRBk&t=749s) Um, and, uh, so as you can see here, the agent is getting, uh, stuck in a bit of a local minimum.

[12:44](https://www.youtube.com/watch?v=2goSS66XRBk&t=764s) Um, but once you apply reasoning-time branching, you get something that works much, much better.

[13:03](https://www.youtube.com/watch?v=2goSS66XRBk&t=783s) So, [clears throat] here what's happening is that the agent is responsible for delegating, uh, parts of its reasoning to sub-agents, which are branched off of an identical copy of the environment, uh, and this is all running on Morph Cloud, um, along with a verified problem decomposition which allows it to recombine the results, uh, and, uh, take them and find

[13:28](https://www.youtube.com/watch?v=2goSS66XRBk&t=808s) the correct move. Um, and so as you can see here, it's able to explore a lot more of the solution space because of this reasoning-time branching.

[13:44](https://www.youtube.com/watch?v=2goSS66XRBk&t=824s) So one thing that I will note here is that, uh, the, um--

[13:51](https://www.youtube.com/watch?v=2goSS66XRBk&t=831s) So this capability is something which is not really explored in other models at the moment, and that's because the infrastructure challenges behind making branching environments that can support large-scale reinforcement learning for this kind of reasoning capability, especially coordinating multi-agent swarms, um, is fundamentally bottlenecked by, by innovations in infrastructure

[14:16](https://www.youtube.com/watch?v=2goSS66XRBk&t=856s) that we've managed to solve here. Um, and because of this, you can see that, uh, now in, in less wall clock time than before,

[14:26](https://www.youtube.com/watch?v=2goSS66XRBk&t=866s) the, uh, the agent was able to, uh, call out to all these sub-agents, launch the swarm,

[14:34](https://www.youtube.com/watch?v=2goSS66XRBk&t=874s) and find the correct solution. So, you know, when I think about the problem of alignment,

[14:52](https://www.youtube.com/watch?v=2goSS66XRBk&t=892s) I really think that, you know, Wittgenstein had something right, and that it was fundamentally a problem of language.

[15:00](https://www.youtube.com/watch?v=2goSS66XRBk&t=900s) I think all problems around alignment can be traced to

[15:08](https://www.youtube.com/watch?v=2goSS66XRBk&t=908s) the insufficiencies of our language. Uh, this Faustian bargain that we made with, uh, with natural language in order to unlock capabilities of our language models.

[15:20](https://www.youtube.com/watch?v=2goSS66XRBk&t=920s) Um, but insofar as we must, uh, go and develop a new language

[15:28](https://www.youtube.com/watch?v=2goSS66XRBk&t=928s) for superintelligence, you know, insofar as the, uh, grammar of the planetary computation has not yet been devised, um,

[15:40](https://www.youtube.com/watch?v=2goSS66XRBk&t=940s) and insofar as this new language must be computational in nature, must be something to which we can attach, uh, you know, algorithmic guarantees of the correctness of outputs. So this is something that Morph Cloud is uniquely enabled to handle,

[16:00](https://www.youtube.com/watch?v=2goSS66XRBk&t=960s) and that's why we're developing verified superintelligence. So verified superintelligence will be a new kind of reasoning model which is capable not only of thinking for an extraordinarily long time

[16:17](https://www.youtube.com/watch?v=2goSS66XRBk&t=977s) and interacting with external software at extremely high throughput, but it will be able to use external software and formal verification software to reflect upon and improve its own reasoning and to produce outputs which can be verified, which can be algorithmically checked, which can be expressed inside of this common language.

[16:40](https://www.youtube.com/watch?v=2goSS66XRBk&t=1000s) Um, and I'm very excited to announce that we are bringing on perhaps the best person in the world for developing verified superintelligence. Um, it's with great pleasure that, um, I'd like to announce that Christian Szegedy is joining Morph as our chief scientist.

[17:01](https://www.youtube.com/watch?v=2goSS66XRBk&t=1021s) He was formerly a co-founder at xAI. He led the development of, uh, code reasoning capabilities for Grok 3. He invented Batchnorm and Adversarial examples. Um, perhaps most importantly, um, he's a visionary,

[17:16](https://www.youtube.com/watch?v=2goSS66XRBk&t=1036s) and he's pioneered, um, he's pioneered precisely this intersection of verification methods, symbolic reasoning, and reasoning in large language models for, uh, almost the past decade.

[17:33](https://www.youtube.com/watch?v=2goSS66XRBk&t=1053s) And we're thrilled to be partnering with him to build this superintelligence that we can only build on Morph Cloud.

[17:41](https://www.youtube.com/watch?v=2goSS66XRBk&t=1061s) Um, and so the demos that you've seen today have all been powered by early checkpoints of a very, uh, a very early version of this verified superintelligence that we've already begun to develop.

[17:57](https://www.youtube.com/watch?v=2goSS66XRBk&t=1077s) And so, uh, this model is something that we're calling Magi One,

[18:02](https://www.youtube.com/watch?v=2goSS66XRBk&t=1082s) and it's going to be trained from the ground up to use Infinibranch

[18:08](https://www.youtube.com/watch?v=2goSS66XRBk&t=1088s) to perform reasoning-time branching, to perform verified reasoning, be an agent that will be fully embodied inside of a cloud that can move at the speed of light. Uh, and that's coming in Q1 2026.

[18:26](https://www.youtube.com/watch?v=2goSS66XRBk&t=1106s) So what does the infrastructure for the singularity look like? Well, we have a lot of ideas about it, but fundamentally, we believe that the infrastructure for the singularity hasn't been invented yet.

[18:41](https://www.youtube.com/watch?v=2goSS66XRBk&t=1121s) And, uh, you know, at Morph, we spend a lot of time talking about, you know, whether or not something is future bound,

[18:51](https://www.youtube.com/watch?v=2goSS66XRBk&t=1131s) which means not just futuristic, belonging to one possible future, but, but something which is so inevitable that it has to belong to every future.

[19:03](https://www.youtube.com/watch?v=2goSS66XRBk&t=1143s) We believe that the infrastructure for the singularity is future bound, that the grammar for the planetary computation is future bound, that verified superintelligence is future bound.

[19:19](https://www.youtube.com/watch?v=2goSS66XRBk&t=1159s) And we invite you to join us because it will run on Morph Cloud. Uh, thank you. [audience applauding] [upbeat music]
