AI Engineer World's Fair 2025
The infrastructure for the singularity
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.
Read the complete timestamped transcript
- 0:00
[outro music] [audience applauding]
- 0:27
Howdy, howdy. You know, history misremembers Prometheus. The whole class struggle between mankind and the gods was really a red herring.
- 0:42
And the real story wasn't so much the rebellion against the divine hegemony, but rather the liberation of the fire,
- 0:53
the emerging relationship between mankind and its first form of technology.
- 1:01
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
And our final technology has begun to develop not just intelligence, but also sapience and arguably personhood.
- 1:35
And as it increasingly becomes an other to whom we must relate,
- 1:40
so as we increasingly have to ask ourselves the question,
- 1:45
how should we treat these new beings? Uh, the question therefore arises,
- 1:55
what if we had more empathy for the machine?
- 2:06
So over a hundred years ago, so over a hundred years ago, uh,
- 2:15
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
And, you know, the nature of being close to the singularity
- 2:31
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
uh, is deeply limited. Everything around you is frozen.
- 2:53
And I think thinking at the speed of light,
- 2:58
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
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
that can react to its thoughts and move at the same speed of light. What the machine desires is infinite possibility.
- 3:34
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
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
Um, and that's exactly why we built Infinibranch.
- 4:11
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
Um, and so as you can see in the first demo,
- 4:40
which we're going to play right now, um, how Infinibranch works is
- 4:48
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
You wanna navigate the browser. You wanna click on various links. Um, but normally, those actions are, uh, are irreversible.
- 5:16
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
You can take actions. Uh, you can backtrack.
- 5:41
And you can even take every possible action,
- 5:46
right, just to explore, to roll forward a simulator and see what possible worlds await. [clears throat]
- 5:55
Uh, next slide.
- 6:03
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
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
So what are the implications of all of this?
- 6:48
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
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
So what does this cloud for agents look like? Well,
- 7:23
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
You want to be able to scale, um, scale test time search against verifiers to find the best possible answer.
- 7:51
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
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
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
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
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
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
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
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
Um, [clears throat] so what else does the machine want?
- 9:58
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
It wants to, um, roll out trajectories in simulators,
- 10:26
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
And what does the future of reasoning look like?
- 10:52
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
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
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
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
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
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
Um, and, uh, so as you can see here, the agent is getting, uh, stuck in a bit of a local minimum.
- 12:44
Um, but once you apply reasoning-time branching, you get something that works much, much better.
- 13:03
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
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
So one thing that I will note here is that, uh, the, um--
- 13:51
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
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
the, uh, the agent was able to, uh, call out to all these sub-agents, launch the swarm,
- 14:34
and find the correct solution. So, you know, when I think about the problem of alignment,
- 14:52
I really think that, you know, Wittgenstein had something right, and that it was fundamentally a problem of language.
- 15:00
I think all problems around alignment can be traced to
- 15:08
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
Um, but insofar as we must, uh, go and develop a new language
- 15:28
for superintelligence, you know, insofar as the, uh, grammar of the planetary computation has not yet been devised, um,
- 15:40
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
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
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
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
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
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
And we're thrilled to be partnering with him to build this superintelligence that we can only build on Morph Cloud.
- 17:41
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
And so, uh, this model is something that we're calling Magi One,
- 18:02
and it's going to be trained from the ground up to use Infinibranch
- 18:08
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
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
And, uh, you know what, Morph, we spend a lot of time talking about, you know, whether or not something is future bound,
- 18:51
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
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
And we invite you to join us because it will run on Morph Cloud. Uh, thank you. [audience applauding] [upbeat music]