Latest / Agentic Conversations (formally mlops.community) / Computers that Think and Take Actions for You

Transcript

Computers that Think and Take Actions for You · Agentic Conversations (formally mlops.community)

0:00
In been 5 to 10 years, the computer will change a lot and
0:08
interface between humans and computer will also change a lot.
0:12
And the fundamental enabler of this is the AI agents who
0:18
understand the human intent and being able to operate the
0:22
digital device by themselves. What's your?
0:32
What's your? Storage I I I started working on
0:35
the AM model since 2016 where I just got into college and people
0:42
working on the soft driving and especially the computer vision
0:48
where you touch the car teach this perception system to detect
0:54
the cars and the pedestrians surrounding you.
0:57
So pseudo heathen and cuz I don't like, I don't like taking
1:06
classes, I don't like doing K exams.
1:09
So I so I find opportunities to to do the research in, in in our
1:17
university's lab. And later I, I was fortunate
1:20
enough to go to Microsoft Research Asia as a second year
1:29
college student, but they typically take graduate
1:33
students. But but I was fortunate enough
1:34
to to prove myself and get into it.
1:37
So I was doing the self driving 3D computer vision prop and
1:43
later I went to Stanford, the FAFA Elise lab who who pioneered
1:51
the computer vision. And there I started working on a
1:55
not just the perception, not just sensing the environment,
1:59
but also taking actions on the environment, which is secular
2:03
robotics, the closer perception action loop, perceiving
2:09
environment and taking the actions on the physical
2:13
environment. This robotics.
2:14
I really like the concept of closing the per section action
2:18
loop. So later I went to MIT for PhD,
2:25
but that's it. But I said just said before, I
2:28
don't like taking classes that I taking exams.
2:30
So I I feel that either I in the future I go to a big company
2:39
such as Google and Meta, etcetera, or starting my own
2:43
company. I don't like go to academia
2:46
because I don't like writing papers.
2:48
So, so that's why while I was doing MITHDMITI started the
2:59
first company called Myshell, which is a agent platform.
3:03
And I will basically provide infrastructure for the creators
3:10
or developers who doesn't know how to build AM models.
3:14
But we provide all those AM models as a Lego bricks so that
3:19
we can orchestrate other models to do their own applications.
3:24
So right now it has around 6 billion active users and it's
3:30
when publicly listed around half a year ago.
3:34
And during that time we also did a lot of open source, open
3:39
source research work because I believe the sciences it's better
3:45
to be to be to be opened. And we released 2 open source
3:49
models at that time. 1 is the open voice mode called Open
3:54
Voice and it released just after Tech PT released their voice
4:01
voicemail. So because our mode at that time
4:05
compares it performs on par with open ammo, but it's free open
4:10
source. So it immediately be called a
4:12
lot of tension and it went straight into GitHub Trelli
4:17
global top one. After two days we put the mode
4:20
on GitHub and there a has around 3035 K stars right now and I
4:27
believe he racks around top 0.3% of the GitHub project that time.
4:35
And we here had another. We has another model later which
4:42
is called Metal TTS which is speech to text model which also
4:48
ranked GitHub global top one. We were, at least based on my
4:54
understanding, we were the only team that has more than one
4:59
projects on premier git up top one in 24.
5:03
Some things can get into once, but it were to to get into the
5:09
fault 1 twice. It's a very long tree.
5:13
Later we released a model called Jet MO E.
5:18
So the concept was, you know, at that time there was the lava
5:25
twister, the Lama to model very famous and a lot of frontier
5:30
labs, they claim they have hundreds of millions or billions
5:34
of dollar to train the model. And it was, it was commonly
5:39
believed that it's impossible for a small team to train the
5:42
model from scratch, although they can of course binding the
5:47
model based on already trained a lot of model about training from
5:50
scratch, doing the pre training stage is extremely challenging.
5:56
So we didn't believe that and we tried to train a model from
6:03
scratch and try to match the Llama 2's performance which was
6:08
trained by hundreds of $1,000,000.
6:11
So give it the cost. We are mainly 2 issues. 1 is
6:14
where we get a data, high quality data and the second
6:18
where we get the compute. Both question are extremely
6:22
critical. Basically you means you don't
6:25
have the feel how to drive a car.
6:27
So so we but creativity likes constraints.
6:33
We so for from the data set. From the data perspective, we
6:38
were able to extract from the public data set and layered data
6:49
set, which means on the bottom there's large quantity but the
6:53
quality is relatively not very good.
6:59
But as it gradually go up into the pyramid, the quantity
7:05
decrease but the quality increase.
7:08
So when we train the model, we first train with the low quality
7:12
data and then gradually converge to the high quality data.
7:15
So even though we don't have the a too much high quality data, we
7:20
eventually converge to that data, eventually converge to the
7:23
data in the training process. So it turns out to be, you know
7:27
extremely effective. And for the model architecture,
7:33
we did a a novel architecture which is called mixture of
7:40
attention, which saved the commutational cost by 75%.
7:43
So eventually we were able to train that model and we've
7:47
around 100K dollars and match the LAMA 2's performance.
7:53
And it was the first time that the community proof sets within
7:59
0.5 million, but zero point $1 million they can train at
8:04
extremely good model. So we caught a lot of attention
8:06
there. Yeah, but that's the the the
8:09
past storage, but it's not quite not quite focused on the current
8:16
model we are building. But that's my my background.
8:19
All right. So you have a very decorated
8:23
past, like you said, going from basically all the top academia
8:28
spots to then training your own large language model at 110th or
8:34
one 100th of a cost that normally it takes to train.
8:39
You've done voice models also, now you're focused on computer
8:44
use. Yeah, computer use.
8:48
That is because we discovered a very grand new opportunity for
8:56
the computer being able to operate itself.
9:00
With computer use, the model is just basically taking the screen
9:03
as input and control the people and mouse.
9:07
So these makes all the tools on the computer available for the
9:15
model to use, not just leaving inside a a a chat box like how
9:22
just we T this. So when the mode have access to
9:26
the computer, it can empower a huge amount of wild card job,
9:34
empower them to have them to to to do faster and even handling
9:38
the job by by the AI itself. And this capability is something
9:44
that Frontier labs such as open air, Google, Anthropic not doing
9:50
quite well. Although they have a very good
9:52
base model, they don't have a very good computer use model.
9:58
And this requires a very, very different training paradigm.
10:03
And given the massive potential and economical potential of this
10:08
capability and also the current states of this field where the
10:15
big lab is now doing hub. So we feel that there's a new
10:19
opportunity to do a new model that around around this topic.
10:25
What is different about training computer use models than
10:30
training large language models? Training large language model.
10:34
It has 2 stages. 1 is called pre training.
10:39
That one is called post training.
10:41
So in the pre training stage open it and probably Google that
10:45
basically feed the entire Internet knowledge formed in
10:52
text format and feed it to the model and let the model to a
10:55
compress and remember and generalize on this knowledge.
11:01
But the issue is that the model is not able to understand how to
11:09
interact with the environment, and they don't understand the
11:13
causality. And what does causality mean?
11:17
Imagine that you're going to driving school and learn to
11:21
drive, and your coach give you all the training materials, for
11:29
example, driving manuals and all the YouTube videos or the
11:33
Internet knowledge of how to drive and just give it to you.
11:36
OK, let you recycle as you remember, but they don't let you
11:42
touch the car. So by training you this way,
11:46
you're able to become a, a very good chatbot a a very good
11:50
person who can understand almost all knowledge with driving and
11:54
seems that you know all the drivers like, but actually
11:58
because you didn't touch the car, you don't know how to
12:00
drive. So which knowledge is missing
12:04
because all the driving materials are written by people
12:09
who know how to drive. I mean, if you read that through
12:13
it, which you know, right? But when you actually learn to
12:16
drive, you learn the causality. For example, your driver on the
12:22
road and you turn the wheel left and then you see the car going
12:27
left, you see the car going left.
12:30
So you understand that this action 'cause that observation
12:34
or that word state and then after you turn left and then you
12:40
turn the reel right and then the car turns right.
12:43
So you have the observation. So you have the action and
12:47
observation and then observation taken by your grain and produce
12:53
the next action. So you clearly understand what
12:56
is the consequence of doing the action, what will be the next
13:01
word state of doing the action. This is strong causality and why
13:07
remembering is driving manuals doesn't give you the causality.
13:12
It's because you don't experience that.
13:15
And even though the driving man is the text contains some
13:21
causality, but is very different from a trying by yourself and
13:27
learn by yourself and learn the strong colloid by yourself.
13:31
And in the pre training data that trope Google, they they use
13:36
they just the text or the videos on the Internet doesn't contain
13:40
any strong causality, especially in the computer use.
13:44
And also considering that the Internet doesn't have too much
13:48
too much computer use data. So they were performing not very
13:52
good in a sub. And how are you then going about
13:55
it? Are you giving models sandboxes
13:58
so they can understand that, or are you training how?
14:02
Like are you training world models?
14:03
Is that what they're specifically called?
14:06
No, we're not training the world models.
14:08
We do have a extremely large scale of the sandboxes so that
14:15
the Asian can run in the sandboxes and do some task and
14:21
collect the trajectories. And we have a reward model to
14:27
help identify which part of trajectory is good and which
14:31
part is now good so that agent can have a feedback signal for
14:35
it to optimize self. So basically learning by doing,
14:39
learning by trows arrows. This is how how to teach the
14:44
most understand the content. So I'm assuming it's a little
14:48
bit easier because the end state, you know, and it's like
14:52
in a way it's did it do that thing or did it not?
14:56
It's not subjective at all. It's very objective.
15:00
And so that gives you the ability to create a stronger
15:03
reward state. This seems correct, but in
15:09
reality how the model reached that state can be can have a lot
15:16
of viruses. For example if they take 10
15:19
steps or 20 steps or 30 steps to go into that state.
15:27
Apparently the 10 step one could be the best, but you cannot
15:31
tell. Probably the 20.
15:35
The 20 step way is the most standard way and it considers
15:40
some other configurations on the computer etcetera.
15:44
So just by checking the end state is actually not
15:51
sufficient. And there's also very
15:55
challenging to actually check the end state because let me
16:00
give you an example. If you're training the agent to
16:04
manage the healthcare training agent to manage the electronic
16:12
healthcare record system, you have a lot of patients and you
16:16
want to transfer the patient data from from a database to
16:21
that healthcare system and you need to copy every every detail,
16:27
every digit into that system. And you have extremely large end
16:32
state is not captured by the single screenshot, is deeply
16:40
integrated with how the computer is deeply integrated with the
16:45
internal state of the computer. And you cannot use the code to
16:53
judge the in state in many cases because those softwares, they
17:00
are very, very exclusive, you actually don't have access to
17:05
the internal state, don't have the internal API of that
17:09
software. So just by filling the forms,
17:12
filling the data, transferring the data is non trivial to judge
17:16
whether it's successful or or not.
17:22
I'm not sure if I I'm not sure if I make it clear, but because
17:28
there are a lot of technical details which which there's the
17:35
the the difficulty cannot understood as judging the the
17:41
end state. So like.
17:44
Tell me about some of the technical details.
17:47
For example, if you're asking the agent to operate the the
17:49
PowerPoint and make a PowerPoint for you, but but it's really
17:58
hard to identify whether it is slice is looking good or not.
18:04
Although it's very easy for the human to understand.
18:07
But if you're training the agent and you there more than 1000
18:13
agent running in parallel and you need something to judge
18:17
whether it's PowerPoint is whether it looks good or not
18:22
because it's not a it's not a objective judgement.
18:27
So it could be very difficult. And also another situation is
18:32
that if you're operating, if you're letting the agent to
18:36
operate an enterprise software and enterprise software itself
18:40
has it's own state, for example, there already a lot of
18:43
information stored on that software, for example, the
18:49
contact information and you need to let agent to modify or
18:54
transfer or send some messages to someone etcetera.
18:59
So, but after you agent taking the action, the word state
19:05
change and you cannot reproduce that state unless you build the
19:10
internal state again. So the agent faces very non
19:15
stationary state during training.
19:18
And although it could be is not very difficult for the humans to
19:23
judge, but it's actually very difficult for the agents to to
19:29
judge because at first they don't have the knowledge of that
19:34
domain. I mean, if they already have the
19:35
knowledge of the domain, then why we need to train them?
19:38
It's a. It's a checking checking
19:41
problem. How are you dealing with the
19:43
state changing constantly? We we must accept that and we
19:48
are training in non stationary states.
19:52
And so you just are figuring out how to make that work within
19:57
your training and and are you simulating these states also
20:04
because you mentioned that you have a lot of sandboxes.
20:07
And then are you simulating different states so that you can
20:10
get that training that happens? We do run a lot of softwares on
20:15
that sandbox and to simulate the environment that agent might
20:19
work on. So by running the agents, we
20:23
collect a lot of trajectories, the screenshot and action
20:27
sequences. And we were able to either use
20:32
humanitation or the training reward model to, to figure out
20:37
which is is good and which is now good and use that to, to
20:42
update them all. And when we train, train the
20:44
model, here's another very, very challenging point.
20:51
So you see the deep sea and also open Anthropic, they use
20:56
reinforcement learning to train their model so that they can
20:59
achieve the international gold medals in math and physics.
21:05
And we all know they are using reinforcement learning and the
21:10
same works in this way. So they first give the model a
21:15
math problem and let the model to, to, to solve it to, to roll
21:18
out the tokens, to roll out the solutions.
21:21
And then they have a judging function to judge whether the
21:25
solution is correct or not. This solution, this judging
21:29
function is very, very single because they only need to check
21:33
whether the answer, the correct answer is in the inside end of
21:39
this light language mode of roll out.
21:42
So they were able to every time they have a map problem, they
21:47
roll out around 10 or 20 times so that the pick out which is
21:52
good, which is not good and to optimize the model based on the
21:59
real signal. And one difficulty that we face
22:04
is that solving the math problem is you don't need to interact
22:08
with the environment. So you just need to roll out
22:10
probably after 2 seconds they finish the roll out.
22:13
But so about interacting with the computer.
22:15
It has the latency you need to do with the worst state, and
22:19
every roll out takes several minutes.
22:21
So several minutes. It is around 100 times longer
22:26
than roll out a math solution. Yeah.
22:30
Yeah. And also you need to maintain a
22:33
extremely large infrastructure. For example, when you manage one
22:38
or two virtual machine or sandbox, it's totally fine.
22:42
But if you have 1000 or 10,000 sandboxes, then you frequently,
22:47
almost frequently encounter the sandbox failure.
22:50
So you need to have a extremely robust mechanism to let it
22:54
recover from the failure. And we, we do have a very robust
22:59
mechanism where during our evaluation we start from
23:04
complete failure, the complete crash of the entire system and
23:08
then see how long does it take for the system to go back to
23:12
normal. And when they're around 32
23:16
sandbox, it takes around 80 seconds to go back to the
23:19
normal, to go back to 100% healthy from 100% failure.
23:25
And if we're around 1000 sandboxes, it takes around
23:31
three, 300 seconds to go from complete failure to complete
23:37
health state. So it is actually quite, quite
23:41
impressive because all those things are automatic.
23:44
And in reality, you won't start with the state where there's a
23:48
complete failure. So you probably don't need
23:51
actually 80 seconds to to do that.
23:57
How are you getting the data for all this, like to train?
24:00
Because I imagine you have to train in specific software, like
24:05
maybe it's Google Flights, or maybe it's HubSpot, or maybe
24:08
it's Salesforce, right? We use all the softwares
24:12
available on the computer and basically we for the real
24:18
website. If we can access the website
24:20
without being blocked, then we use that real website directly
24:24
used and run reinforcement learning on Google Face and for
24:32
other crowd apps, for example Google Docs or Microsoft
24:38
PowerPoint or Microsoft Words, Yeah, we just use the software
24:42
and we just install them in the sandbox and running.
24:47
But I guess there's, there's going to be instances where the
24:53
agent encounters software that it wasn't trained on and you're
24:57
going to want it to be able to try things and make it work,
25:03
right. So maybe it wasn't trained on
25:05
HubSpot, but it was trained on Salesforce and you're going to
25:10
hope that it can go and figure out HubSpot.
25:14
When the agent is trying to operate a software they never
25:18
seen before and we at least hope that he can have a cold start.
25:26
This comes from 2 perspectives. 1 is that because the agent
25:33
already see a lot of data, a lot of screenshots data and a lot of
25:38
data that is being trained on. So it has a relatively general
25:47
understanding of how the UI works.
25:51
So that when they see a new screenshot, see a new software,
25:59
at least they understand that OK, that button is set.
26:03
If I go to that button that probably change, change the
26:07
thing to dock. So that's a general knowledge
26:11
which is observed by operating with your existing software.
26:18
So I mean, if that doesn't work, we'll collect the human data to
26:22
let humans to operate the computers and operate the
26:26
software tend to give the model some prior knowledge.
26:30
So that come from one is the natural generalization from
26:38
existing training, and the second part is human teaching
26:42
them toys. And the human teaching them, or
26:47
the human data that you're collecting, you then fine tune
26:50
the models with. Yeah, we, we, we fine tune the
26:55
model with human data and we actually collect a huge amount
26:59
of human data. And it is not called fine tune,
27:03
is called meat training, where there's a huge amount of data,
27:11
much more than what the typical fine tuning need.
27:15
Yeah. So it's it's not fine tuning it.
27:18
It's basically like step 2IN training.
27:21
Yeah, OK, so I'm starting to get a picture of this and tell me if
27:26
I'm going down the right track. You have a large amount of
27:31
sandboxes, you have models that are trying things inside of
27:36
these sandboxes, and then they're getting rewarded when
27:39
they are completing the right task in the best way possible,
27:45
meaning I imagine the least amount of steps.
27:49
So from there you get a base model that understands how to do
27:57
things with your computer, like scroll and take a screenshot and
28:01
then submit, click buttons, whatever it may be, go back and
28:05
forward. And then when you want to use a
28:11
specific tool that is a tool that the models never seen
28:16
before, you're giving it human data.
28:21
So you can do that stage 2 training.
28:25
That's very correct. The model needs to have first
28:27
have a general knowledge and and then trained on a relatively
28:32
specific tools. And the general and the training
28:37
needs to happen in these sandboxes or the sandboxes are
28:41
just how you're generating data to then train.
28:45
Yeah, the sandbox, it is only for generating the data because
28:52
training needs a lot of GPU needs a relatively centralized
28:55
infrastructure where the sandboxes are just the desktop
29:01
environment of Ubuntu or Windows or Mac OS, they're just just
29:06
playing desktop environment and let the agents runk.
29:10
But the agents, but when we collect the data, the agents is
29:15
not trained inside the sandbox, is trained on a GPO cluster in
29:20
our training infrastructure. Yeah, and we actually already
29:26
open source our training infrastructure with a lot of
29:30
sandboxes and oh, oh, by the way, we, we just launched our
29:35
model in December 1st, just yesterday.
29:39
Yeah. And I can actually send you the.
29:46
Yeah, tell me more about the model.
29:48
Yeah, you see the comparison between the locks thinker and
29:52
also. All the other computer use,
29:56
yeah, doing really well. Yes, yes, doing extremely well.
30:02
And the online metro and benchmark is the benchmark with
30:05
around 300 real work computer use tasks and it's widely known
30:12
in the community. So many models are evaluating on
30:15
that benchmark and we were able to reach a score of 83.6, which
30:24
is much higher than Google's Gemini model and also open
30:30
operator and also cloud. And it's not just more powerful,
30:37
it's also faster. So it's on average 2 two time A2
30:42
to three times faster than this competing models.
30:47
And also the token cost is around just 10% of these models.
30:52
So it's extremely powerful. And we are releasing the model
30:55
and also the SDK and also the API so that the developers can
30:59
build their their own computer use applications.
31:03
And so now I've seen quite a few folks trying with computer use.
31:09
It's captivated our imagination. Why did you feel like you wanted
31:13
to go to the model level versus trying to just give existing
31:18
models more infrastructure? That is because the current
31:22
model is not good enough and by giving the infrastructure you
31:28
cannot solve the fundamental performance issue, you cannot
31:32
stop the speed issue and you probably have higher cost.
31:36
So by giving the model probably some tools and it can do
31:43
something more easily, but it's not general enough.
31:47
And also if, if I'm starting a company, but just wrapping
31:54
around others model and what is my my competitive edge, We must
32:02
have some very fundamental have our own space in the in the, in
32:09
the field of computer models. And I I think that is, that is
32:15
not a easy path, but it's definitely the most promising
32:20
past in the long run. Do you feel like you also want
32:26
to or need to add to the different framework layers also?
32:31
Or is it something that you're just going to focus on the
32:34
model, make sure the models as good as possible and let others
32:38
build on top of? It very good question.
32:41
I so when released the our model called Lux, we also release the
32:48
agent framework. For example in our SDK page
32:52
there is a thing called Tasker Agent.
32:56
What is Tasker Agent? It's a agent structure that is
33:03
based on our Lux model. But it gives extremely high
33:09
controllability for a fixed workflow.
33:13
For example, in that agent, the task agent, the developer can
33:17
specify each to do, each precise to do for the model to do each
33:24
sub task so that the model can do it 1 by 1.
33:28
And inside the task agent, if a sub task is not completed
33:37
correctly, then the model will know how to make up the mistakes
33:43
and correct mistakes. So basically the task agent can
33:49
give the developer extremely high controllability to do a
33:54
workflow 1 by 1, to do repetitive workflow step by step
33:59
and do it fast and have the ability to correct it's own
34:03
mistakes. If you're just using the model
34:05
itself, it's not very easy to achieve that level of
34:09
controllability. So we also build the framework
34:13
around that one model. There are three three ways to
34:17
use the model. 1 is called the actor mode where it runs placing
34:21
fast and much faster than existing competitive models.
34:26
And the second mode is called thinker mode where it's able to
34:33
handle vague queries and long horizon task and it can think
34:37
before it take take actions And it can also run for more than
34:44
one hour on a task. And it needs to let me in the
34:49
middle even encounter some problem.
34:52
It knows how to fix it by itself.
34:55
That is the thinker thinker mode.
34:58
And there's also a task mode which we just talked about it,
35:05
where it offers extremely high controllability.
35:08
And these is especially suitable when you already know how to do
35:15
this workflow, but you just need an agent, just need an intern to
35:18
help you to do it. So you need to give the intern A
35:21
to do list or subtask list and can do it with extremely high
35:28
controllability and stability. In the Thinker mode, and
35:33
actually for all these different modes, how different was it to
35:37
train each of them? Or was it just that stage 2
35:41
training that was the different part?
35:42
You had the base model and then you added these different
35:46
flavors of the model. Or are you just giving more
35:50
compute at Test hunt at runtime for the Thinker?
35:55
Yeah. So the training is actually
35:58
very, very similar. We share the first stage of
36:02
training. In the second stage, for the
36:04
actual model, we prioritize the speed, so we don't like the
36:08
model thing too much. But for the Thinker model, we
36:11
like the model, think extremely deep.
36:13
So it's basically the stage. Stage 2 training is quite
36:16
different. The objective or the
36:19
authorization purpose is different.
36:24
OK. So Stage 2, you're just giving
36:26
it more time to think about what it's going to do and then try
36:30
it, come back, try again, that type of thing.
36:34
Yeah, yeah, yeah, exactly. And this is so cool.
36:38
What have you done with it so far?
36:43
You mean the model release? Or like what you playing around
36:48
with the model? What are some things that you've
36:51
done? Yeah.
36:52
Yeah, yeah. So we actually have some
36:55
examples that we really like on the website.
36:58
For example, letting the model to software QA is the one
37:06
example is doing the software QA where you are developing a
37:11
software and you add a new feature.
37:13
You want to make sure all the features are functioning
37:18
correctly. So you need to run over the
37:21
software and do the QA on each part.
37:24
So this is something that can be done with the with the Tasker
37:28
agent where you specify all the features you want to test, all
37:32
the to do's. So you just do it 1 by 1 and
37:37
every time you add a new feature you can spin.
37:42
So every time you add a new feature you can start a task of
37:48
agent in a virtual machine and add it to the QA for you.
37:52
Another example is finding the insider trading activities for
37:58
all those stocks. So he just have to he just asked
38:04
the model to find the insider trading activities for Apple
38:09
stocks on NASDAQ. So he will just go to the
38:13
website and search for the APL and then inside the page,
38:19
somewhere in the page is able to find the insider trading
38:23
activities. That's an interesting example.
38:26
Wow, yeah. Yeah.
38:28
And also helping you filing your, your text on TurboTax is
38:33
able to just fill those boxes 1 by 1 and based on some
38:41
information that you you give it.
38:45
That's a godsend, especially right around March, April time.
38:52
So we're, we're building the so we're increasing the reliability
38:59
of the model. So that's so that you can
39:04
completely trust it. So there's another very
39:10
important aspect about the visibility of the of the model,
39:15
because for some tasks, when the model operates the computer, you
39:19
actually want to have the control of it.
39:21
But for some task you don't even want to look at it.
39:25
So to be specific, there are three situations. 1 is the
39:31
completely background task, for example, helping you to query
39:37
information from Amazon or buying a toilet paper on Amazon.
39:41
So you don't even want to take a look at it.
39:46
So in in that case the agent just do it.
39:49
And the second level is where you don't care the process, you
39:57
just care the results and when. So in the last stage you need to
40:04
check the results. So the second level is where the
40:08
agent can do the process, but you need to confirm at the end,
40:12
but you actually don't don't care or don't want to look at
40:15
the process, for example feeding your information.
40:21
To the health insurance provider, you want the agent to
40:25
do it, but before the agent hit submit, you want to stop and you
40:31
check it and you hit submit and the text filing is also this
40:36
category. You want agent to do it, but
40:39
actually you don't want to submit for you.
40:42
You want to check before you submit.
40:45
And the second level and the third level is where you want to
40:51
see every step of the agent doing, for example, moving your
40:58
bank information from here to there or feeding some extremely
41:06
important information where you don't want any digit going well.
41:11
So in that case, you observe the agent step by step.
41:15
So for those 3 scenarios, we offer a different for, for, for.
41:22
For these three scenarios, we offer different visibility for
41:27
for the developers so that they can build corresponding
41:32
applications. One thing I think about a lot
41:35
with computer use models is sometimes I also want to be
41:40
using my computer. And So what in your mind does
41:46
the infrastructure look like for these different models?
41:49
Is it that they are going out into the cloud and doing things
41:54
or they're not doing this on your computer, they're looking
41:59
at other resources or they're doing it in the background like
42:02
you said. But then maybe it eats up if it
42:05
is doing it on my computer the whole time, it eats up all of my
42:09
memory or my just my computer usage.
42:14
Yes, so the the local background node can have its own virtual
42:22
desktop on the local machine, so they can do without without
42:28
interfering with your work. So you can still use the
42:31
computer, but it's doing it in the in the in the background.
42:35
It's also possible to run it on the cloud machine, but you have
42:38
to to upload some information to the cloud machine or it or if
42:43
you only ask if do some browser operations and it can just
42:48
retrieve the information from the browser and that's
42:50
completely fine. So they're they're they're
42:54
different. Most all are postal.
42:58
Dude, what else do you want to talk about?
43:00
I would like to talk about the last thing our imagination and
43:05
vision of the future of computers.
43:09
Because we see several stages evolution of stages of computer
43:16
in the in the history. The first one is probably the
43:19
mainframe and the second one is the PC and the third one is the
43:24
mobile phone. And what is the 4th one?
43:29
It is very likely that in the future the computer will not in
43:33
these current form. It's possible that the keyboard
43:40
will disappear, the mouse will disappear or you have some other
43:45
input format such as the voice to let the computer understand
43:49
your intent and then the computer can do it for you.
43:54
And probably we can still have some, some keyboard, but
43:57
eventually the computer, it starts subscribing just like the
44:01
current sub driving cars. But this probably won't happen
44:06
in in one or two years, But in between 5 to 10 years, the
44:13
computer will change a lot. And interface between humans and
44:18
computer will also change a lot. And the fundamental enabler of
44:24
this is the AI agents who understand the human intent and
44:28
being able to operate the digital device by themselves.
44:34
So we are going towards that direction right now is computer
44:37
use. And the future is probably just
44:41
AI operation system, AI operating system that is
44:46
completely autonomous and you only have a hardware and you
44:50
don't need to touch it and you just say your intent and it does
44:54
and it does the things for you.