Revolutionizing AI Learning: Induction Labs Unveils Photon-1's Imagination Model

Induction Labs Photon-1 is a new AI model that can simulate desktop screens, play checkers, and even predict billiard physics from one pretraining run. What makes it stand out is that it learned from raw computer videos without action labels, which means nobody had to tell it which mouse click or key press caused each screen change. The team says this imagination model learned by watching how screens changed over time, then used that skill to become a computer-using agent with lower training cost than many people might expect.

Home: Why Photon-1 Starts From Video Instead of Action Labels

Most AI agents that work on computers are trained like a student who is forced to copy every tiny step from a teacher, including each click, drag, and key press.
That sounds helpful at first, but it creates a hard limit, because collecting those action labels for huge amounts of video is slow, expensive, and messy.
Induction Labs takes a very different path with Photon-1, and that is the main reason this research is getting attention in AI and computer vision circles.
Instead of feeding the system detailed action logs, the team lets the model watch screen recordings and learn from how the world on the screen changes from one moment to the next.
You can think of it like watching someone clean a room through a window without hearing their instructions.
Even if you do not know every hand movement, you still understand the goal, the order of steps, and what a clean room looks like at the end.
Photon-1 tries to learn in that same way, except the “room” is a desktop screen and the “cleaning” is a computer task like opening apps, logging in, or filling forms.
The model is based on what Induction Labs calls an imagination model.
That name is useful because the model is not just memorizing frames like a camera roll.
It is trained to predict what the next state of the screen should look like in a learned internal form.
That means it builds a rough mental map of what usually happens next during real computer use.
If one window opens, a menu appears, or a button gets clicked, the model learns the pattern of change.
This matters because tasks on computers are really chains of state changes.
When a person sends an email, installs a program, or checks a dashboard, they are moving the computer from one state to another until the goal is reached.
Photon-1 learns those chains without being told the hidden action behind every frame.
That is why the paper talks about an implicit policy.
In simple words, the model seems to learn what people are trying to do, even before it is formally trained to output actions.
This is a bit like learning the rules of a game by watching many matches before ever touching the controller yourself.
By the time you finally play, you already know what smart moves usually look like.
For SEO readers searching terms like Photon-1, Induction Labs, imagination model, desktop simulation AI, and video pretraining, this idea is the core story behind the project.
It suggests that future AI agents may not need mountains of hand-labeled action data to become useful.
That could lower the cost of building smarter agents for real desktop work.

Tutorials: How the Imagination Model Predicts the Next Screen State

To understand Photon-1, it helps to stop thinking about pixels first.
The system does not mainly learn by drawing complete images during pretraining.
Instead, it learns a compact hidden form of each frame and predicts the next hidden pieces, often called latent tokens.
This process is called next-latent-token prediction.
That term may sound technical, but the idea is simple.
Imagine reading a comic book where each panel shows what happened next.
After enough pages, you begin to guess the next panel before turning it.
Photon-1 does something similar with screen states.
It sees one state, then another, then learns which changes usually come next.
This method is important because computer screens are full of patterns.
Buttons highlight when hovered over, login boxes appear in certain places, tab bars stay in familiar layouts, and file windows open in predictable ways.
A model that watches enough screen recordings can start to understand these patterns at a deeper level than simple image matching.
Induction Labs argues that this future prediction skill teaches task structure.
That means the model is not only learning how a desktop looks, but also how work tends to unfold on that desktop.
For example, if someone opens a browser, types in a box, waits for a page, then clicks a result, the model may learn the meaning of that sequence.
Even if no one labels the clicks, the order itself carries useful information.
This is why the idea feels powerful.
Many older systems depend on action labels like “move mouse left” or “press enter now.”
Photon-1 tries to reach a broader understanding first and action ability later.
After pretraining, the team fine-tuned the system on fewer than 35,000 computer-use trajectories.
That number is much smaller than the giant pretraining video set, which suggests the model already knew a lot before official action training began.
At inference time, Photon-1 first predicts the state it wants to reach, then outputs the action that should move the computer there.
That order is very interesting.
It is a bit like a person picturing the finished puzzle before deciding which piece to pick up next.
Instead of reacting blindly, the model seems to use a target state as guidance.
This can help explain why the system may work better on tasks that require planning across several steps.
It also helps explain why the model showed skill outside normal desktop work, including checkers and billiard prediction after fine-tuning.
The research idea here is not just about faster AI.
It is about teaching machines to understand change, intention, and sequence in a more natural way.

Robotics: The Compression Trick That Lets Photon-1 Scale

One of the biggest problems in video AI is size.
Raw video is huge, and desktop video still contains lots of detail like text, icons, pop-up boxes, cursor moves, and layout shifts.
If a model tries to process every pixel directly at large scale, cost rises fast.
That is why Photon-1 uses a strong compression method built around finite scalar quantization, or FSQ.
Each frame is compressed into 960 discrete tokens.
Each token is an 8-dimensional vector, and each dimension can take one of five values.
This gives the model a structured codebook for describing a frame in a much smaller form.
The reported result is about 2.2 KB per frame.
That is small enough to matter a lot when training over hundreds of millions of frames.
A good real-world comparison is zipping a giant school project folder before sending it.
If the zip file stays clear and usable, sharing becomes easy.
If the zip file ruins the pictures, text, and charts, it becomes useless.
Photon-1’s encoder aims for the first outcome.
It tries to shrink the screen while still keeping the important parts like text, layout, and state changes.
Induction Labs says this is more than 100 times better compression than older OCR and multimodal-style representations.
That claim is striking because OCR alone often misses the full meaning of a screen.
OCR may read text, but it can lose visual structure, spacing, icon location, and subtle changes that matter during real computer use.
Photon-1 needs more than plain words because using a desktop is not just reading.
It is understanding where things are and how they change over time.
The team also uses what it calls a differential latent encoder.
That means the encoder often focuses on differences between paired frames instead of treating every frame like a fresh world.
This makes sense for screen recordings, because many parts of the screen stay the same while only one small region changes.
Think about writing in a document.
The toolbar, menus, and page frame remain almost unchanged, while only a blinking cursor and a few words move.
If your system stores the whole screen again and again, it wastes space.
If it stores only what changed, it becomes far more efficient.
This same idea is common in everyday life.
When a friend says, “Only the due date changed,” they do not repeat the full homework sheet from the start.
They give just the meaningful update.
Photon-1 appears to learn from screen changes in a similar way.
This compression strategy is not a side detail.
It is one of the main reasons the training setup becomes possible at scale.
Without strong compression, the dream of learning from years of desktop video would be much harder and much more expensive.

Newsletter: Training Data, Compute, and Why the Cost Story Matters

Photon-1 was trained on a very large set of public video data, but the story becomes more interesting when you follow how that data was filtered down.
The team started from an internal index of 2 billion publicly available videos.
From that giant pile, they filtered the set to around 2 million computer screen recordings.
Then they removed redundant frames with an internal keyframe detection model.
The final training set had 575 million frames sampled at 1 frame per second.
That works out to about 18 years of video and roughly 552 billion tokens.
So while the model learned without action labels, it did not learn from a tiny or casual dataset.
It learned from a huge watching experience, like a student who spent years observing people use computers in many different ways.
The model itself is described as a sparse 106B-A5B mixture-of-experts transformer.
In simple terms, it is a very large system, but only part of it is active at a time, which helps keep compute more efficient than a dense model of the same full size.
The reported pretraining cost is around 30,000 H200 GPU-hours at 32K context.
That is about 4.4×10²² training FLOPs.
The team says training reached about 40% end-to-end MFU using PyTorch and custom fused kernels.
Those numbers matter because the company compares Photon-1 with Gemini 3.1 Flash-Lite on an internal computer use benchmark.
Induction Labs says Photon-1 beats that model while using far less pretraining compute and a lower serving cost.
The table in the article gives Gemini an estimated pretraining compute of 1.200 × 10²⁴ FLOPs and a weighted inference cost of $0.36 per 1 million tokens.
Photon-1 is listed at 0.044 × 10²⁴ FLOPs and $0.11 for the same token unit.
That makes Photon-1 look much cheaper in both training and use.
Still, careful readers should keep the caveats in mind.
The Gemini number is an estimate from Induction Labs, not an official number from Google.
The benchmark is also internal and not publicly released yet.
So this is promising evidence, but not the final word.
That balanced view is important for trust and for SEO content quality.
It helps readers understand both the excitement and the limits.
Photon-1’s own breakeven cost is also interesting at $0.06 per 1 million input tokens and $0.60 per 1 million output tokens.
Those details matter for businesses thinking about AI agents that must work at scale every day.
If an agent handles thousands of desktop tasks, even small cost differences become huge over time.
It is like choosing between two school buses.
If one bus costs a little less per trip, the savings look small on day one, but across a full year the gap becomes very big.
That is why compute efficiency is not just a lab number.
It changes what companies can actually afford to deploy.

GitHub: From Desktop Tasks to Checkers and Billiard Physics

The most exciting part of the Photon-1 story may be that it did not stop at desktop simulations.
Induction Labs also tested whether the model could generalize into other worlds that were not part of its original pretraining data.
This is where the checkers and billiard results become important.
If the model had only learned shallow desktop tricks, it should struggle badly outside that area.
But after fine-tuning, Photon-1 outperformed two baselines in domains not seen during pretraining.
One baseline used the same architecture and size without imagination pretraining.
The other was an LLM baseline called Ling-flash-2.0, which had been pretrained on 20 trillion tokens.
In 20,000 tournament checkers games, Photon-1 did better on world simulation and move quality.
That suggests it was not merely identifying board pictures but learning how state changes flow over time in a rule-based system.
On 10,000 synthetic billiard games simulated at 5 frames per second, Photon-1 reached a mean absolute error of 0.47.
The LLM baseline scored 1.15, and the vision encoder baseline scored 1.44.
That gap is large enough to make people pay attention.
Billiards is a strong test because it depends on motion, collision, angle, and timing.
It is closer to physical reasoning than simple board pattern matching.
A useful analogy is this: imagine a student who learned by watching lots of people use laptops, and then later turns out to be unexpectedly good at predicting how checkers pieces move and where billiard balls will roll.
You would start to think the student learned more than screen layouts.
You would think the student learned deeper rules about sequences, outcomes, and state transitions.
That is the larger research promise here.
The same future-prediction skill that helps on a desktop may also help in other structured environments.
The article also notes that after reinforcement learning, Photon-1 learned to use an in-VM ChatGPT-style clone to draft artifacts and answer knowledge questions.
That is a small but very human-like detail.
Instead of acting like a sealed robot, it learned to use another tool inside its workspace the way a human worker might.
If you have ever watched someone complete an online form while checking another tab for information, you have seen this kind of behavior in daily life.
However, readers should remember one practical limit.
There are no public weights, no API, and no public license right now.
So Photon-1 is still a research result, not something developers can plug into products today.
Even so, the paper points to an important direction for future AI agents.
Teaching a model to predict how worlds change may be a strong path toward systems that can work across many tasks, not just one narrow benchmark.

Conclusion

Photon-1 shows a bold idea in AI: a model can learn useful behavior by watching screen changes instead of relying on detailed action labels. Induction Labs says this imagination-model approach helped Photon-1 simulate desktops, act on computer tasks, and even transfer to checkers and billiard physics after fine-tuning. The research also stands out because of its strong video compression method, large-scale pretraining setup, and lower reported compute and serving cost compared with a major benchmark rival. Even though the benchmark is internal and the model is not publicly available yet, Photon-1 gives a clear sign that future AI agents may become smarter by first learning how the world changes over time.

Source: https://www.marktechpost.com/2026/07/26/induction-labs-photon-1-simulates-desktops-plays-checkers-and-models-billiard-physics-from-one-pretraining-run/