AI never sleeps and this week has been absolutely insane. Anthropic releases their best model Claude Fable 5, but then it also gets killed in less
than a week. This is now the best open-source AI for animating characters with a reference video. Google drops an incredibly fast open-source model
plus a free real-time translator. Kimmy just released their latest model and it's an absolute beast. And
also my favorite open-source lab ZAI quietly drops their latest model GLM 5.2. Minimax also released their best open-source model and an incredibly
efficient architecture. This AI can create 4D full-body avatars. We have a ton of really cool 3D model generators plus another top text-to-speech
generator and a lot more. So, let's jump right in. First up, we have probably the best open-source AI for
transferring motion from one video onto another video. It's called Scale-2 and first of all, here are some examples. As you can see, this can even
transfer the motion of more than one character. So, on the top is the original video. We can change the input frames instead to these two characters
fighting in a forest and here's our result. Note that it matches the movement of the original video very
well, even though this is quite a high action and tricky scene. This can also do non-human animals. For example, at the top is the original video. We
can change the woman into a flamingo and it's still able to preserve roughly the same movement. This even works if the input or output character has
some weird aspect ratios or dimensions. For example, if your output is a chubby creature like this
with abnormal proportions, it's still able to detect, you know, the skeleton of this character and animate it appropriately. Here's another example
where we can easily replace one character with another character in a video. Not only does this work with realistic videos, but also anime and other
artistic styles. And if you compare this with other open-source motion animators like One animate or
the first version of Scale, note that this new Scale 2 is just a lot better. I'd say the quality is even on par with the closed-source Kling 3. Here's
another example for your reference. Note that Scale 2 is even able to capture the camera movement of the original driving video, whereas Kling was not
able to do so. And then here's a comparison with multiple characters, and as you can see, Scale 2
is by far the most performant. It's able to consistently maintain the details of both characters. The awesome thing is this is out already. So, at the
top of the page, if you click on this code button and you scroll down a bit, here it contains all the instructions on how to download and run this
locally on your computer. Note that if I click on the Hugging Face repo, the total size of all the
models is 81 GB, so we'll probably need to wait for some quantized versions or GGUFs to be able to run it on most consumer devices. By the way,
interesting thing is if you look at the affiliations here, this is also by Ziai, which is the company behind GLM, one of the top open-source models
out there. Interesting how they're also contributing to AI videos as well. If you're interested in reading
further, I'll link to this main page in the description below. Also this week we have a pretty interesting AI system called Actionable World
Representation. This is basically a way to build a moving digital twin of real-world objects. And the reason it's interesting is that it doesn't just
predict what an object looks like. It tries to model how that object can actually change, bend, or move. So,
this takes real-world 3D data like point clouds or even just a depth video, and it outputs a controllable 3D model of that object as it moves. So,
instead of just generating a physical 3D object, it also generates the object's motion. And what makes this impressive is the range of objects it can
handle. The demos show articulated objects like a hand or an entire human moving to things like
deformable earphones or even the Unitree dog robot. This matters because if we want robots or AI agents to act in the real world, we need more than
hard objects in simulations. We also need accurate representations of how these objects move. The awesome thing is they've released this already. So,
if you click on this code button and you scroll down a bit, here it contains all the instructions on
how to run this on your computer. If you're interested in reading further, I'll link to this main page in the description below. Also this week, we
have a new AI called Oscar and this is a world model for robots. In simple terms, it tries to predict or simulate what would happen when you tell the
robot to take a certain action. For example, clearing the dining table or inserting a capsule in a
coffee machine or lifting a pot by the handle, inserting a plug, etc. The impressive part is this is designed to work across different robot bodies,
not just one specific arm or one specific setup. Instead of relying on a robot's exact appearance, Oscar uses a 2D skeleton style motion as the
control signal as you can see here. This makes it easier to transfer across different robot arms or
different models. And the model can focus on motion structure instead of memorizing what each particular robot looks like. Here you can see that it's
able to generate videos doing a variety of tasks like manipulating different objects to making lunch. And you know, this AI is really valuable because
right now we don't have enough real-world video data to train humanoid robots well. So, what we
could do is just train them in a virtual environment or use AI to create a ton of synthetic training videos like this to train robots. If you compare
Oscar with other robot video simulators, you can see that Oscar is a lot more similar to the ground truth compared to the other models. Here's another
example for your reference. Now, at the top of the page, they have released the code to this. So,
if you scroll down here, it contains all the instructions on how to run this on your computer. Note that here they do recommend an Nvidia GPU with
over 24 GB of VRAM. Plus, the awesome thing is this is under the Apache 2 license, which has very minimal restrictions. If you're interested in
reading further, I'll link to this main page in the description below. Also this week, Google releases Gemini
3.5 live translate. This is their new real-time translation model. Basically, you can talk in one language and it would speak out a translated version
using your same voice almost in real-time. Here are some examples. >> [music] >> Good morning, sir.
I'm not sure where I am. Let me look around first. I think I'm at the main gate, but I don't see your car. >> I am further down near the
I understand. I'm at the other pickup point. Let me walk a bit further to find your car. >> It's great to see you both. Cassie, how's the weather
in Shanghai? >> It's nice to meet you. The weather here is really nice. I spent the whole day with my family in the park. >> That sounds wonderful.
Anna, you mentioned last week that you were celebrating your birthday. How was [clears throat] it? >>
Oh, it was fantastic. I had dinner at my favorite restaurant with some friends. If you visit Sweden, you must try this restaurant. >> Okay, Cassie,
can you update us on the website rollout in Asia? >> We've received approval for the website update. The launch in the Asia-Pacific region is
proceeding smoothly as planned. We are on track to >> Okay, that's great.
Note that here it can automatically detect over 70 languages, and it also tries to preserve the speaker's intonation, pacing, and pitch. And it also
tries to keep the conversation natural. Unlike turn-by-turn translation systems that wait until someone finishes talking, Gemini 3.5 Live Translate
generates continuously while staying only a few seconds behind the speaker. So, that means fewer
awkward pauses and smoother back and forth. The awesome thing is this feature is already available via their API as well as Google's AI Studio, which
you can try for free. So, simply click on this link and you can try it here. And apparently, this is available for everyone via Google Translate on
Android and iOS. Welcome to our tour of the beautiful city of Cartagena. We will walk through its
cobblestone streets to admire its impressive architecture. And we will end the day enjoying a beautiful sunset. So, now we can all be lazy and not
need to even learn a new language. We can just pull up Live Translate when we are traveling in a foreign country, and it will help us translate
whatever we say on the fly. Super useful tool. If you're interested in reading further, I'll link to this
main page in the description below. Also this week, Google releases Diffusion Gemma. This is their open-source model, which is incredibly fast. Now,
this is a bit different from regular language models, which you may be used to. You see, most language models write text from left to right, one token
or word at a time. But this Diffusion Gemma model generates text more like an image generator by
using a diffusion model. Instead of generating text one word at a time from left to right, this actually drafts blocks of text in parallel and then
refines them over multiple passes. So, rather than just predicting the next word and then the next word, this works on a whole block of text at once.
And here Google says that this can reach up to four times faster text generation compared to regular
auto-regressive language models. And you know, the really cool thing is you can even get this to do pretty complex stuff like solving Sudoku or
generating 3D models, as you can see from this example. Now, historically these diffusion language models have performed pretty badly in terms of
generating text, reasoning, and world understanding. They're not as good as normal language models. But if you
look at these benchmarks, then this new diffusion Gemma in light blue actually performs pretty close to Gemma 4, which is a regular auto-regressive
language model of the same size across these knowledge benchmarks like MMLU or GBQA, which is graduate-level scientific knowledge, as well as
competitive math and coding. The nice thing is this model is already released, and this is under a very
permissive Apache 2 license, which has very minimal restrictions. You can even use this for commercial purposes. Now, on this Hugging Face repo, note
that the total size of the model and some additional files is around 52 GB, so you'll still need a high-end GPU to run this, and that's because this
is 26 billion parameters. If you're interested in reading further, I'll link to this main page in the
description below. Next up, this AI is quite interesting. It's called Stream Force, and this is a video generator where you can control the motion by
applying forces directly in the video. So, here are some examples of this in action. For example, you can apply force this way, and it'll basically
generate a video of the clothes being blown in that direction. Or here are a few other examples.
Instead of just using a prompt to dictate how the objects move, you can now just push objects in a video using a force signal. And you can also change
that force over time. Think of it like giving an AI video model a physics joystick. Now, this supports local and global forces. So, here, if we use a
global force, it's like applying wind that affects the whole scene. Or if we use a local force,
then it only applies that force on one part of the scene, for example, like moving just one chair or just moving this apple. Now, the important part
of this is it's also causal and streaming, which means it can react in real time as you change the force signals. The page says that stream force runs
up to 16.6 frames per second on just a single CPU. Now, at the top of the page, it does say the code
is coming soon, so hopefully they will stick to their word and release this. For now, if you're interested in reading further, I'll link to this main
page in the description below. Also this week, we have a new very important benchmark called Agents Last Exam. You see, this is basically a stress
test for AI models doing real professional work, not just answering random knowledge questions or
solving tiny coding tasks. The idea is simple. If AI agents are supposed to help with actual jobs, then we need benchmarks that look more like actual
jobs. So, instead of asking an agent just one isolated question, this benchmark gives it much longer and practical workflows with clear outcomes. So,
here, you can see it covers tasks across 55 sub industries, including animation, neuroscience, 3D
modeling, architecture, manufacturing, game development, engineering, and more. So, for example, agents might have to complete animation and VFX work
in After Effects or create 3D models or set up scenes in Unreal Engine or run some analyses in medical software or do architectural modeling using
another app. Basically, it's trying to measure whether agents can survive real workflows where the task
is multi-step, it's specific to a certain domain, and it's actually used in real work. And if you look at the leaderboard, then you can see that
GPT-5.5 Codex is actually the best. It even beats Claude Fable 5. Here, there's also a footnote. Most of the time, Claude Fable 5 will just outright
gate you, and even if it does decide to answer you, it might silently and secretly give you a dumber
answer by default. Even rerunning it can't correct that. And here, as you can see, GPT-5.5 using Codex, which is what I use personally for most of my
daily tasks, does perform the best in terms of these real-world agentic tasks, followed by GPT-5.5 and Open Claw, and then surprisingly, the new
Composer model by Cursor also does very well. So, a pretty interesting benchmark for you to put on your
radar. At the top, they have released a GitHub button, which contains instructions on how you can run this yourself. If you're interested in reading
further, I'll link to this main page in the description below. Also this week, we have a new system called Arbor, which is really useful for
autonomous research. The easiest way to think about it is this. As an AI agent doing research, this makes it
so that it doesn't just try one idea and then fail and then forget what happened. Instead, it builds a living research tree. It takes the research
objective and breaks it down into hypotheses, it runs experiments, it saves the evidence, and then it uses those results to decide what to do next.
Basically, it turns research from a messy sequence of disconnected attempts to a more cumulative process,
where you can refine and iterate further. The key idea is called hypothesis tree refinement. So, we have this overarching coordinator, which manages
the overall strategy, and then we also have these executors that test individual ideas in isolated instances. These are like the temporary research
assistants that implement just one experiment, they run it, and then they report back. And then each
node in the tree basically keeps track of each hypothesis and experiment. And this matters because AI agents often struggle with continuity. They can
edit code and run short tests and do one specific task, but they often lose sight of the big overall picture. But here with Arbor, this is a system
where the agents can keep track of what it has learned and compare it competing directions and iterate
further. Now, the really cool thing is if you look at these benchmarks comparing Arbor with standard harnesses like Claude code or Codex, it performs
even better across all these different categories like optimizer design or architecture design, agentic coding, math reasoning, etc. And some of these
gains are pretty significant. And that's why this Arbor system is so interesting. This is a system
for AI models to do more structured and persistent work. The awesome thing is they've released this already. So, if you click on this GitHub repo and
you scroll down a bit, here it contains all the instructions on how to get started on your computer. Also, this is under the Apache 2 license, which
is very permissive. You can even use this for commercial purposes. If you're interested in reading
further, I'll link to this main page in the description below. If you've ever had a creative idea that sounded exciting at first, but then turned into
a mess of tabs and different tools, then you should definitely check out Luma agents by Luma AI, the sponsor of this video. Luma agents is basically
an AI workspace designed to help you bring creative projects to life from start to finish. But the
key difference is that it's not just another AI generator. It's built around agents that can collaborate with you across the entire creative process.
So, instead of jumping between separate tools for brainstorming, planning, design, video generation, and execution, you can work inside one connected
canvas where the agents understand what you're trying to make and keep the whole project in context.
And that context is a big deal. Luma's technology is built around understanding the physical world including motion, space, camera movement, and how
things behave visually. So, when you're working on something creative, the agents are not just responding to isolated prompts, they can help reason
about the actual world your project is trying to represent. You can start with a rough concept for a
video, a brand idea, or a visual scene. From there, the agents help you develop the idea, organize the next steps, and coordinate different parts of
the workflow behind the scenes. In other words, you stay in the role of creative director. You bring the taste, vision, and final judgment. The agents
help you structure the chaos and handle more of the execution layer, so you don't get stuck managing
10 different tools just to make one thing. And that's what makes it feel really useful for creators. You can test more ideas, iterate more freely, and
keep the whole project moving without losing track of the original vision. Whether you're making videos, designing visuals, or building campaigns,
Luma Agents is the perfect tool to use. Simply scan the QR code or use the link in the description
below to get started. Also this week, one of the top Chinese labs out there, Kimi, released their best and latest model, Kimi K2.7 Code. Now, Kimi has
always been at the top of the leaderboards in terms of open-source models, and their K2.6 model was already very good. But this week, they made an
even more performant model, which is super exciting. So, as you can see from all these different
benchmarks, not only is Kimi K2.7 better than K2.6, but it's also edging very close to the top closed models out there, including GPT 5.5 and Opus
4.8. Super impressive for an open-source model. Also, if you look at this chart, the x-axis is the number of tokens used, so the lower the better it
means it's more efficient, and then y-axis is performance, so higher is better. Ideally, you want to
move towards the upper left corner, and that's indeed what you get with Kimi K2.7, which is the blue dots. Here are some additional specs for your
reference. So, as a state-of-the-art open-source model, this is quite huge at a trillion parameters. This is a mixture of experts model, so when you
use it, only 32 billion parameters are active, so this is very efficient. Now, as before, they've
already open-sourced Kimiko 2.7. So, if you go on Hugging Face and you look at the model, at a trillion parameters, this is quite huge at almost 600
GB in size, so you'll need a pretty massive setup in order to run this locally. Here, they say that K2.7 is designed to do even better in terms of
reasoning efficiency. So, it overthinks less of the time, plus it has improved instruction following,
and it's more optimized for long horizon coding tasks. On this page, if you scroll down a bit, it contains all the instructions on how to download and
run this locally on your computer. Alternatively, if you don't have a beast of a setup at home to run this, you can also subscribe to Kimiko to run
this. If you're interested in reading further, I'll link to this main page in the description below.
Now, a few weeks ago, one of my favorite labs, MiniMax, announced their latest and best model, MiniMax M3, and they said it will be open weights. And
this is one of the best open-source models you can use. If you look at this chart from Artificial Analysis, then you can see that MiniMax M3 is indeed
the leading open-source model out there, even ahead of Kimiko and Mimo and Deep Seek V4. Well, this
week, they stuck to their word and released the model, which is fantastic. By the way, this is an incredibly performant, but relatively small model.
So, this is only like 427 billion parameters, whereas Kimiko or Deep Seek are a trillion parameters. So, this is less than half the size. Now, this is
a mixture of experts model, so when you use it, only 23 billion parameters are active, plus this has
a massive 1 million token context window, meaning you can fit a ton of information into your prompt at once. Now, at over 400 billion parameters, this
model is still pretty huge, so the full model is over 850 GB in size. If you want to run this locally, again, you'll need some insane hardware to do
so. They also released a smaller FXMP8 version if you have the right hardware to run this, and this
is much smaller at 444 GB in size. Now, the reason why they were able to jam-pack all this intelligence in just 400 billion parameters, whereas the
other top open models are over a trillion parameters, is largely due to this mechanism called the Minimax sparse attention. This allows the model to
understand huge amounts of context faster and cheaper. The awesome thing is they've also released the
code and technical report on this. So, in really simple terms, this takes part of the language model that normally tries to look at everything in the
context window, and instead teaches it to quickly pick the most useful blocks of information before doing the expensive attention step. The idea is to
add a lightweight indexing branch that stores chunks of memory, chooses the top chunks for each
attention group, and then lets the main attention branch focus on only the selected blocks. You can think of it as like giving the model a smart table
of contents before it reads a massive book. By the way, Minimax isn't the only one to release such a mechanism. DeepSeek also has their own technique
called DeepSeek sparse attention, and then Kimmy also released their own way to handle a huge
context window efficiently. In fact, if you're interested in learning a bit about both these architectures, I'll link to this video and this video,
which go over these details in simple terms. Now, Minimax also released the technical details to their own sparse attention mechanism. It's great that
these top Chinese labs are actually publishing this information for the community to learn from,
whereas the top closed labs haven't really contributed anything. Anyways, if you are interested, I will link to this page on Minimax sparse attention,
as well as this page on the Minimax M3 model in the description below. Also this week we have another frontier open source model. This is called Next
N2 and this is built around the idea that reasoning should be used for action including coding and
long horizon tasks. Note that this is trained from Qwen 3.5 as the base model. Instead of creating search, coding, and tool use as totally separate
behaviors, Next N2 tries to use one consistent thinking pattern across all of them. The useful part is this adaptive reasoning feature. The model can
decide when to think harder and when not to instead of forcing expensive reasoning on every single
task. And if you look at these benchmarks, this performs incredibly well. This even beats leading open models like DeepSeek-V4 and GLM-5.1 across
various agentic and coding benchmarks. In terms of Deep Sweet, it even scores 33.6 significantly beating the other open models. Now note that this
family consists of two different models. There's a pro variant which is 397 billion parameters. This is a
mixture of experts models so think of it as like a team of AIs working together and when you use it only 17 billion parameters are active so this is
fairly efficient. And then they also have a mini model. This is a lot smaller at 35 billion parameters and only 3 billion parameters are active when
you use it. The awesome thing is this is out already. So at the top here, if you click on this GitHub
link, it takes you to this page which contains all the instructions on how to install this. Note that for the pro model because it is quite huge at
almost 400 billion parameters, the total size of the model is 794 GB whereas the mini model is a lot more accessible. This is only 70 GB in size. If
you're interested in reading further, I'll link to this main page in the description below. Also this
week we have yet another frontier text-to-speech model which is actually very performant. So this is quite a small 2 billion parameter model. You can
just input a few seconds of someone's voice, and this AI can basically get that voice to speak out this transcript. So, it has like zero-shot voice
cloning. Let's listen to a few examples. >> The fact we were able to complete the construction work on
schedule is a testament to everyone's hard work. How could you possibly believe such an obvious lie? Daniel questioned incredulously, his eyebrows
raised in disbelief. The story doesn't even make logical sense if you think about it for more than 5 seconds. >> Unfortunately, we haven't made any
real progress. Uh well, Lisa Terek stuttered, nervously extending the ring he bought for God knows how
much. Mhm, will you marry me? >> As you can hear, it sounds almost exactly like the original reference voice. Plus, it can even do subtle stuff like
stuttering. Or here's another example where this can even do whispering. >> [snorts]
[snorts]
[gasps] [sighs] >> This can also do multiple languages, even if the input reference voice doesn't speak that language. For example, let me play you
the input voice first, and then let's get it to speak out all these different languages. >> Which is what has brought us to this point in the first
place.
Now, if you look at this chart, the X axis is the error rate, so the lower the better, and the Y axis is the similarity compared with the reference
voice, so the higher the better. Ideally, you want to be in this upper left corner, and that's exactly where dot TTS is, even outcompeting other
recent TTS models like C TTS, Voxy PM, Quan 3 TTS, and Index TTS 2, all of which I featured on my
channel before. The awesome thing is they've released this already, and it's under the Apache 2 license, which has very minimal restrictions. You can
even use this for commercial purposes. If you click on this GitHub repo, here it contains all the instructions on how to download and run this on your
computer. Now, at 2 billion parameters, this is fairly tiny, so the base model is only around 5 GB
in size. You should be able to fit this on most consumer GPUs. If you're interested in reading further, I'll link to this main page in the description
below. Also this week, Anthropic releases their flagship model, Claude Fable 5, which they claim is mythos quality. Now, I already covered a ton of
personal tests and specs and benchmarks in my previous video, so see this if you haven't already.
I'll put it in the description below. But, a ton of other crazy things happened over the course of the week, which I didn't cover in that video. So,
let's talk about this a bit more. I already mentioned that Fable is severely nerfed. It appears to be one of the most locked down frontier models
released to the public, especially around AI research, model training, cybersecurity, and biology. In
many cases, when you ask it questions related to these fields, it will simply refuse. But, here's the biggest red flag and the most controversial part
of its design, especially if you're asking it to do things in AI research, machine learning, or model training. Hidden deep in its system card paper,
which is over 300 pages long, is this paragraph, which states the following. If you ask it to do
things in regards to like AI research, training models, machine learning, it secretly gives you a dumber answer. It doesn't outright refuse you.
Instead, the model could intentionally give you a significantly weaker or incomplete answer or steer you somewhere else, essentially sabotaging you.
For developers, especially in AI or machine learning, this is a serious trust problem. Now, of course,
many users, including myself, were not happy about this, and in the middle of this week, they did retract the sabotaging mechanism, but honestly, the
trust has already been broken. They say that it's not going to sabotage you, and instead, it's going to explicitly refuse or request, but we don't
really know if they're still secretly getting the Claude models to weaken your answers behind the
scenes. And that's the main problem I have with Anthropic. Even though they do have very capable models, they constantly gatekeep and rug pull their
users. It's really challenging to keep using them. Now, that wasn't the only update about Fable this week. So, last night, Anthropic announced this.
They say that the US government issued a directive requiring it to suspend all access to Fable and
Mythos for foreign nationals, including foreign national Anthropic employees. Because of that, Anthropic says it must disable Fable and Mythos for all
customers to stay compliant, including all Americans, by the way. While other Anthropic models are not affected. So, yeah, I guess we all don't even
have access to Fable now. What a crazy turn of events. Now, this opens up a ton of different
unanswered questions. If the US can issue this ban for Anthropic, will they potentially also do it for OpenAI or Google once they release better and
better models? And if so, is US still the best place for AI labs if the government can just suddenly require you to suspend your product? And here,
they're removing access for everyone, but let's say they can offer it to US citizens. How would that
even be enforced? Would they need to do like KYC? Do they need to scan your ID or scan your iris or something? There are just a lot of unanswered
questions. And Anyway, this whole Fable release took quite a sharp turn at the end there. Let me know in the comments what you think of all of this.
Now, shortly after the Fable lockdown, one of my favorite open labs, ZAI, was quick to jump in and
announce that GLM 5.2 is now available on all GLM coding plans. And the model will be officially open-sourced next week, which is fantastic. This is
the open-source model I'm most looking forward to. Now, currently, there's no like system card or technical report or benchmarks released for GLM 5.2.
It's all coming next week. But, if you want to head start and access GLM 5.2, I'll link to this page
where you can subscribe to the GLM coding plan. Also this week, we have a new AI called world tracing. This is a new way to turn a single image or
even a short video into a layered 3D model. So, this takes an image and outputs not just the visible depth, but multiple layers of hidden geometry
behind what the camera can actually see. Think of it as like giving every pixel a little stack of 3D
points. The first point is the surface, which you can see, but the later points are the parts behind it. Things like the back of an object or the wall
behind furniture, etc. What makes this useful is that once you have this layered geometry, you can do much more than just make a nice 3D preview. It
can lift the layered point cloud into a textured mesh without extra retraining. It can also support
3D edits like adding or removing objects or even guide video generation with 3D geometry references. So, a really powerful and flexible tool. The
awesome thing is they've released everything already. So, if you click on this code button and you scroll down a bit, here it contains all the
instructions on how to install and run this on your computer. Note that there are three different models. One
model is for generating a static object, another one is for generating a static scene, another one is for generating a moving 3D object. The model is
quite tiny, it's only 6.2 GB in size, so you should be able to fit this on most consumer GPUs. If you're interested in reading further, I'll link to
this main page in the description below. Also this week we have a new AI called Flex 4D human, and
this can turn simple human videos into full body 4D reconstructions. 4D here means 3D with the added dimension of time. So basically a moving 3D human
model which you can view from different angles. Now this can take either a single video, so for example here is one video reference and as you can see
it's able to create a 3D model of this character moving which you can view at different angles.
And this is much more performant than other methods. Now instead of just one video, you can also input multiple videos. So here's an example of two
different videos and this gives it more data and makes its generation even more accurate. In addition to two references, here's an example with four
references which gives it even more data and makes it even more consistent. What's interesting is that
it doesn't rely on explicit skeletons or depth maps or surface normals or any traditional methods. This just uses AI to reconstruct everything from
the raw camera footage. And because it's now created a 3D model, you can then plug this 3D model into any scene or edit it further like this. If you
scroll up to the top of the page, they have released a code button and here it says the code release is
in preparation, so stay tuned for that. If you're interested in reading further, I'll link to this main page in the description below. Also this week
we have a new AI called Video MDM. This is about training AI to generate 3D human motion without needing any 3D mocap data. So here what they did is
they took just ordinary videos in 2D, but they extracted accurate body poses and used that to train a
model which can then generate coherent 3D human motion. Here are some examples for your reference. Just from a text prompt, it can generate the full
3D motion of a human performing the action such as a person waving with his right hand or a person walking backwards in a straight line. It
understands a ton of different actions like deadlifts or push-ups or barbell dead rows. At the top of the page
they have released the code to this. So, if you click on this button and you scroll down a bit, here it contains all the instructions on how to
download and run this locally on your computer. Note that this is under the MIT license, which is fairly permissive. If you're interested in reading
further, I'll link to this main page in the description below. Also this week, this AI is pretty cool. It's
called Surf Flow and this is a system for turning multiple images of scene into one clean 3D model. It uses all the input views into one shared global
3D state. It even works if the images are not aligned or even if the camera positions are not known. It keeps one compact global understanding of the
scene and that understanding simply gets better and better as you give it more views. So, instead
of carrying around a huge amount of repeated image information, Surf Flow uses those extra photos to fill in missing parts of the 3D model more
cleanly. Now, at the top of the page they have released a code button to this. Here it says, "We will make our code and data available as soon as
possible. So, stay tuned for that." If you're interested in reading further, I'll link to this main page in
the description below. Also this week, we have Moverse. This is an AI that turns a normal image into a 360° panorama world which you can move around
and interact with in real time. So, here are some examples of this in action. All you need is just one image and it would transform it into pretty
consistent 3D world. The impressive part is that this works real time at 8 frames per second on just a
single RTX 4090. This isn't some really expensive enterprise GPU. The important trick is that Mover separates world construction from video rendering.
So, first it fills in the missing surroundings with a 360° panorama, so the model is not only working with a limited small part of the image. Instead,
it expands the original image into a huge wide-angle panorama like this. Afterwards, it turns that
panorama into a 3D Gaussian model, which acts like a reusable spatial memory of the scene. Finally, the video renderer takes views from that reference
along with a user-controlled camera path and turns it into a coherent video. You can see here it works with a ton of different environments including
a cartoon or 3D environment like this, or even an oil painting like this, or even Ghibli style.
Now, the quality isn't great. This is quite blurry and low resolution, but this is rendering 8 frames per second in real-time on just a consumer GPU.
So, this is incredibly efficient. At the top of the page they have released a code button, and here it says the code and models are currently under
corporate compliance and review. It'll likely take about a month to review, and then afterwards they
will release all materials. If you're interested in reading further, I'll link to this main page in the description below. Also this week we have a
new fully open-source image model from Princeton called I1. This is fairly performant, so here are some examples of its generations. This can do
photorealistic images as well as different art styles and anime, and this is also great at text rendering.
So, here are some examples of its generations with a ton of text. Now, that being said, this is not the most performant model out there, and they were
quite honest about this, so this is behind Z image and quant image, likely behind ideal gram and Ernie image as well, which were released recently.
However, the biggest value from this is that they open-sourced everything. Here it says that leading
open models just released the models but not the training data or the full recipe, so we don't really know how this works. If we want to train an
image model from scratch, we don't really get a lot of insights. But here the awesome thing is they've fully open-sourced this. They released the
models as well as the training and inference code and the data processing pipeline for this. So if you click
on this code button, it takes you to this page and down here it contains all the information on how you can run this yourself as well as the links to
the data set and the data pipelines. Note that this model is quite tiny at 3 billion parameters and this is around 12 GB in size. So it should be able
to fit on most consumer devices. So if you're looking to just generate images, this isn't the best
model out there. I would not recommend this, but if you want to study how an image model can be trained from scratch, if you want to study how to
correctly format the data set and the data pipelines to train this, this is a very valuable resource. If you're interested in reading further, I'll
link to this main page in the description below. Also this week, this AI is pretty cool. It's called
Anchor World and this is basically a first-person world simulator where the model is controlled by real human motion. So here are some examples of how
it works. You would input some human motion moving through a scene in 3D like this and the output is a first-person video of this person moving around
the scene. Think of it like instead of only typing a prompt or pressing keys in a world simulator,
you guide it with a person moving through the scene instead. Now in addition to inputting just the human action in 3D, you also input some anchor
views like this. This is basically an image for how that part of the scene should look like. Then after plugging in the human motion, it's able to
render the scene from a first-person perspective of the human. Here are some additional examples for your
reference. Note that this isn't just getting the person to walk around. This simulator can also get the person to interact with objects such as
operating the sink or holding this knife. So, a pretty interesting idea. This could be potentially used for creating egocentric videos for training
humanoid robots to do various tasks. Now, at the top of the page, it does say that the code is under review,
so it looks like they are planning to release the models to this in the future, which is great. For now, if you're interested in reading further, I'll
link to this main page in the description below. Also this week, Meta surprisingly released a really fast 3D generator called Mesh Flow. So, this can
either take a prompt or a point cloud or a reference image and generate an actual 3D mesh with
vertices and edges, not just a cloud of points or some soft shape. So, here are some generated meshes for your reference. And the key here is speed. A
lot of generation methods create meshes step-by-step, almost like writing a sentence a token at a time. Well, Mesh Flow instead compresses that mesh
into latent space using something called Mesh VAE, and it's able to sample from that space much
faster. In fact, here they claim that it's 18 times faster than other generation methods. The nice thing is they've released the code to this already.
So, if you click on this code button and you scroll down a bit, here it contains all the instructions on how to run this on your computer. If you're
interested in reading further, I'll link to this main page in the description below. Also this week,
we have this new AI system called MilliVid. This tackles one of the hardest problems in AI video, which is making long consistent videos. You see,
current video models can make some impressive short clips that are like 5 to 20 seconds long, but once you ask them to continue for a longer time,
they often lose consistency or forget what different parts of the scene look like, or it just gets a lot
more error-prone. Well, MilliVid aims to solve this problem. As you can see, even for really long videos, it's able to maintain consistency much
better than other methods. Now, how they solve this is they use something called a hierarchical autoencoder. Basically, each frame is represented at
multiple levels of detail. The coarse level captures the big stuff like the layout and semantics, while
the finer levels capture texture and appearance. And then, the model generates video in a coarse-to-fine rollout. And apparently, this lets it
remember the scene and structure much better and for much longer. Now, at the top, they do have a code button. And here, it says that the paper will
be released on June 12th. At the time of this recording, it's not out yet, but by the time this video is
published, the code should already be out. If you're interested in reading further, I'll link to this main page in the description below. And that
sums up all the highlights in AI this week. Let me know in the comments what you think of all of this. Which piece of news was your favorite? And
which tool are you most looking forward to trying out? As always, I will be on the lookout for the top AI
news and tools to share with you. So, if you enjoyed this video, remember to like, share, subscribe, and stay tuned for more content. Also, there's
just so much happening in the world of AI every week, I can't possibly cover everything on my YouTube channel. So, to really stay up-to-date with all
that's going on in AI, be sure to subscribe to my free weekly newsletter. The link to that will be in
the description below. Thanks for watching, and I'll see you in the next one.