AI Engineer World's Fair 2025
The infrastructure for the singularity
Loading slides…
Read the talk
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.
From a talk by Jesse Han
Before you start: 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
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?
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
When the environment cannot keep up
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Branching and backtracking a whole computer
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The Liquid Metal announcement
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A workspace becomes a search starting point
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 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:
- Parallel agents try different ways to start the server from the prepared environment.
- One attempt fails and another succeeds.
- 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Software environments as simulators
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Branch the reasoning and its environment
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Toward a computational language of verification
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The research team and Magi One
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 with Sergey Ioffe, and the early adversarial-example research with six collaborators.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Infrastructure that belongs to every future
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
Further reading
- Batch NormalizationPaper
Sergey Ioffe and Christian Szegedy’s original paper introducing batch normalization for neural-network training.
Early research by Szegedy and collaborators showing that small image perturbations can cause neural-network misclassification.
Updates since the talk
Current guide to creating VM snapshots and starting new instances from saved environments, with Python, TypeScript and CLI examples.
Python SDK and CLI for VM branching, cached snapshot chains, command execution and Docker integration.
Full transcript
Loading transcript…