The Autonomous Computer: Infrastructure for Computer Use Agents — Ang Li, Simular

A little bit about my background. Um, I'm the co-founder and CEO of Simular, and this year is pretty much the, like, the s-thirties years that I've interacted with computers. And now I'm trying to build computers that's fully autonomous, so I don't have to interact with that. And i-if, if I look, look back to my history, the first ten years, I'm, uh, I, I basically get to know computer pr- when I was pretty young. The first ten years, I focused on competitive programming, like basically writing code every day.

And the s-the second decade, I spent a lot of time, uh, training neural nets, basically published a lot of, uh, AI research papers, uh, during my PhD and later on in DeepMind. And the third, um, uh, the third decade, so I joined DeepMind in twenty seventeen. That's the beginning of the third decade. So this year is twenty, uh, twenty-six. Al-almost ten years. So so when I, when I first joined DeepMind, we really tried to solve this problem called AGI, artificial general intelligence, and back

then everyone was still confused. Uh, even now it's-- everyone is still confused about what's the definition of AGI. But in general, it's kind of like a general system, kind of like, like human, uh, humans, like, like a machine can do all different kinds of things in there. And, uh, hopefully next year we can solve the problem. So I, I can think about, uh, what would you do, what kind of problem to solve, uh, for the, for the fourth decade. Okay, so I want to, uh, start my talk now. Um, basically, the reason I want to introduce that is

because I spent ten years on coding, ten years on neural nets, ten year, ten years on solving AGI. So that actually gi- that gave me the, this, this kind of bias that we, we try to inject to our current company that we have this, uh, this kind of principle in mind. The general AI system needs to be neurosymbolic. Basically code combined with neural nets. So, so which I will, I will show you quickly why, uh, like we have this kind of intuition in there. So the goal for

this workshop, I know we are, we're kind of, uh, short on time, and, uh, I do want to give, uh, three things back to you. First is basic knowledge about computer use. Uh, w- I understand fifty percent of you are still new to this domain. And second is, uh, the tools we, we have been working on as part of the infrastructure. There are four different type, type of components that we believe would be helpful to your future development of computer us- uh, applications. And I will also show some applications that other people has been working on, uh, other developers.

And third, which is important, uh, since, uh, what we have a product called Sai, and this product is still closed beta right now. So I want to give everyone invitation code at the end of the, the workshop, so you have a, you know, opportunity to play with the product. Also, do let me know. Uh, feel free to follow me on, uh, Twitter and join Discord. Let me know if you need more credits. So, so I definitely like, uh, give more credits in there. So the first question is, what is, uh, computer use agents?

Right? So, uh, normally what I do with the, with my talk is I can take a selfie here

with everyone. I will take half. Yeah, so, so this is what I do every day now. So actually, I'm, I'm the CEO, so I don't use computer all day long. I have my agents on my phone, so I can text my agent, send a photo there

and say, "Post the photo to LinkedIn."

Yeah, and then the agent will, will be working on it. So let's see. So I do want to sh- see if the agent is responding there.

Oh.

I think I got some...

Okay, so let's see.

So I do have my message there. Okay, the agent is responding, so it has my photo there. And you can see the agent is starting to ask me questions there. So, uh, I'll, uh, I won't interact with the agent right now, but I want to show you the basic interface. So computer use agents means, means a agent that has a computer, which is a full Windows desktop in this scenario. And if I continue interacting with the computer, the mouse and keyboard, it, it know it's gonna work on this desktop and open a LinkedIn later.

And I will go back to the presentation. I just show you an example of having one agent, so I can talk to the agent, a agent that, uh, working on the applications. But actually, you can have multiple. That's what we are actually working on. So, uh, these, these are four agents. You can see they have different names, right? So QA agents is basically like, uh, doing QA on the products. Testing product is one big use case in there. They also research customer support, go to

Discord channel, and looking at all of the informations there. So the, the actual agents are slower. So it's actually-- th-this, this is recording for like hours, so I just compressed that into thirty seconds for you to basically grab the, you know, the basic understanding of, of how computer us- agents is working there. So the general idea, this is very different from, um, most of the agents that we talk about right now. Like most of the agents, they are based, based on APIs, and you don't actually see vi-visually what the agent is doing. Computer

use agents is another category, and we believe is a, is a, is another bigger category which can do a lot more things that you, you don't have APIs. You can still let agents to work on it. And then I want to do a little bit of ritual 'cause we started the company in twenty twenty-three, right? And that was, uh, right after GPT-3.5 and, uh, GPT-4V. So I wanna show you one example that two years ago, we kind of, we kind of hopeless two years ago on this problem in there. I actually

posted on, on Twitter. So this is my tweet. And let me pause a little bit. This is my tweet two years ago. So the, the problem is like, can we actually use GPT-4V to understand the screen and then click on the iMessage icon on the screen? Ve-very, very simple, trivial, trivial problem. And I basically used the model, built up a iterative refinement of the, the

grounding. You see the, the mo-- the first time is, is not correct. The second time is go to the mailbox icon, and the third time is click on the iMessage. So this is, this is the only one successful demo I did. So, so, so I asked, I asked the agent to, to click on Zoom. It doesn't work at all. So two years ago, this problem is basically hopeless, but we kinda have the intuition that, uh, foundation model is gonna be better and better over time. Eventually,

this problem will be solvable. But it's just like it's not possible within two years. Back in, uh, our, um... That actually motivates us to think about what's the general strategy for solving this computer usage agent, uh, problem. And we do have a name for that. It's called autonomous computer because in, you know, like, if the computer can do all different kinds of things, it's autonomous, right? And then the question is: How do we solve autonomous computer?

So when I, when I talk about it, there are only two words: autonomous and computer. So it's become so natural, two directions you think about. One is the autonomy, the other is computer, right? Autonomy meaning, like, do we have a system that can actually understand the context, the environment of the, of the computer, and do all the reasoning, planning, can recover from its own mistake. Um, like doesn't require human to babysit in the, the agent. And the second part is computer. Like, what kind of computer, uh, the agent can use?

So this is a core question, but back then, two years ago, we feel computer is actually easy problem because everyone already have computers, right? So that's why we focus a lot on the autonomy part. So when we talk about autonomy, this goes back to the, the underlying principle we initially have. It's called neurosymbolic. Neuro means-- this also happens to self-driving car. It's basically the, the same concept for all different kinds of autonomous system. They all have the same concept. You, you, you have a component that's neural. Here is a VLM,

vision language model, v-VLM agent. And the second part is, uh, symbolic. And here is, uh, we ca-call it coding agent back then. And basically, we need to solve these two technology in order for us to make autonomy works. And I just show you a demo. Two years ago, VLM doesn't work at all, right? So that's why we actually spent a lot of time two years ago working on the coding layer to ensure, okay, like we can actually control the computer in a more reliable way. But the second problem is we, we set up a research team two years ago to think

about, okay, how can we make this crappy VLM better in terms of using the u-u, uh, using the computers? Um, before I start talk about the, the trajectory, our journey on the VLM agents, I want to, uh, briefly talk about the, the signals. Like, you know, like self-driving cars, uh, like Waymo running on the road, they have signals, lidar, radar, and, uh, and like camera, right? Three different kinds of signal. Computer had the same. So I, I often

tell people like, "Okay, we, we are actually working on self-driving cars in a, in a computer, in a digital world," basically chaining a steering wheel to your mouse and keyboard. So we still have three different kinds of signals. One is screenshot, the other accessibility tree. So accessibility tree is very unique. It's, it's kind of rare, you know, in our, in our daily life. DOM tree is pretty popular because we use browsers. Accessibility tree is a kind of a, um, still kind of like a DOM tree, but this is, this is, uh, tied to each of the operating system. Mac has

its, its own accessibility tree format, and Windows has its, like a separate protocol for accessibility tree. But this is the basic, the, the, the layer that operating system use to render all of the windows, all of the icons on, on your screen in there. So this part is very important. It's because, um,

yeah, th-these are the, the effort we've been working on. It's called Agent S. So the whole idea is can we build our harness? So two years ago, we don't call it harness. Nowadays, everyone call it harness. So two years ago, we, we build our-- we try to f-finish this project called Agent S, build out a harness, bui- uh, uh, build upon all of the foundation models, not just one. So you can easily switch models. It's model-agnostic framework that allows you to produce the best, uh, computer usage capability in there. And the first

generation was done in late twenty twenty-four, and it's called Agent S. Uh, we just call it Agent S because that, that's the beginning. And this agent achieved twenty percent success rate on OSWorld, twenty percent. And that was the state of art, state of the art, uh, back then in twenty twenty-four, which is very interesting. And this paper, uh, this paper also won the best paper in ICLR twenty twenty-five Agentic AI workshop. You know, the, the, the, the whole industry w-was moving so

fast over the past year and which is crazy. And this, the, the choice for this harness is because first we know vision language model is so bad, it's not gonna work. So that's why we chose to use accessibility tree in the first generation. Basically, we look at all of the, the underlying protocols of the tree structure f-to describe the current environment and pass it to a large language model instead of vision language model. And use ID, ID-based grounding, basically

linearize all of the, all of the buttons, put them IDs, and ask LLM, like, which button-- What's the ID of the button where I need to click on right now? It kinda works. It's twenty percent, which is super exciting because in the beginning, this benchmark is like five percent success rate in the early twenty twenty-four in there. And then early twenty twenty-five, we started to see, okay, vision language model is getting better. So the second generation of Agent S, we actually tr-- uh,

completely dis-discard the accessibility tree. So it's a vision-only approach. And the interesting part is th-this architecture, we have multiple layers, like managers and workers, so it's kinda like human organization. And we showed it kinda works. And this work specifically was, um, a lo- a lot of friends in Silicon Valley actually talked to me about this work. They, they feel pretty excited about this work. The reason is this method demonstrate that

if you have two models, you are better than one models. If you have two foundation models within the same harness, it's better than one, uh, foundation models. And the second foundation model is a seven billion open source model. So yeah, so mo-- All of the startup friends, they are pretty excited about it because, okay, there's a, there's an alternative. Like, I can train some small models, and we can t- be twenty percent better than, uh, like, Claude or OpenAI, uh, computer agents there. And late

twenty twenty-five, we have our third generation Agent S, and the whole idea of this, uh, part is can we actually do test time scaling? It's called inference time scaling. It's when you have a agent, can you have multiple agents to try to attack, uh, solve the same task, and eventually you have better performance. And we demonstrate it works. So this is, uh, the figure for the total resource budget, meaning the total number of workers versus, uh, times the total number of steps. And it's, it's for, like, fair

comparison. And you can see if you have ten agents, they actually scale better in terms of success rate. So then in December, we break the human performance, uh, record in OS World Benchmark. And these are comparison of all the trajectory between, uh, among all, uh, Agent S and, and Anthropic and OpenAI. Uh, both big labs, they achieve the same human performance, uh, in March this year. And that also, uh, it's, uh, last December was a

exciting moment. Like, we feel, okay, like, computer user agents is finally start to be somewhat useful. But, you know, this benchmark is kinda research benchmark. It's-- It doesn't mean, like, in real life, uh, it's already a hundred percent, it's already better than human. Um, a few days ago, OS World has, uh, has released their second generation called OS World 2. I'm, uh, specifically excited about this new benchmark. So, um, in the new benchmark, the best performing model is only twenty percent in that benchmark. So, so we

are, we are entering the second phase of computer us- agents in there.

I wanna show one, show you one video. Uh, there was a very interesting, um, demo that, uh, one of the developer used. So th-this project actually won the CalHacks last year. So it is, it's, uh, it's, uh, one of the biggest hackathon in, uh, hosted in, in Berkeley. And they, they built their applications based on Agent S, the open source one.

Sometimes you may do something on your computer, but you're already outside.

I guess, uh, you probably don't s-- uh, hear the voice.

To go back. What if you can control your computer from anywhere in the world just by FaceTiming it? We built a multimodal agent with full control of your computer. So instead of calling your mom to debug your CUDA out of memory errors, you can just FaceTime your Mac instead. Let me show you how it works. Okay, so suppose that you're training an AI model at home, but you already left, and you just realized that you had a CUDA out of memory error. So what's the easiest way to fix this? Well, instead of driving all the way back home, you can just call your computer and tell it to do it itself. So we can

call it and text it to FaceTime me, and then this will initiate the computers agent right here to, uh, start a FaceTime call so that I can tell it what I want it to do.

Yeah, they, they did a very interesting thing.

Let me make it quicker.

And so now I can see what the thing says. Can you fix my CUDA out of memory error in VS Code?

Okay, the task is to fix the CUDA out of memory error in VS Code. I will hit Command-Space VS Code to open the application.

So these are all automatic-

Okay. I'm in VS Code-

-by computers

... and I'm looking for the CUDA out of memory error. It looks like this file has a CUDA out of memory error. Based on the comments, it looks like the tensor size is too large, so I should try to decrease this to something reasonable.

Yeah, I think as you kinda get the idea, the, the idea is, uh, build a application that you can control your computer using FaceTime and use FaceTime to debug in VS Code. That was happening in October last year. That's before, like, even OpenClau was, uh, started as a project in there. Then we had to think about what's the second, uh, you know, second phase of computerized agents in there. So we already surpassed human performance in the benchmark. Like, what's next? Then we realized, okay,

there's actually a very interesting concept of, called pass to the power of K. And in the past, everyone was measuring pass at K, meaning it is pretty popular in, in vibe coding, like you, you have a task, you ask, you ask the agent to, uh, produce the code, right? If the code doesn't work, and then you, you put some prompts in there and produce another, another, uh, code in there. One of the code becomes successful is successful 'Cause you don't care about what's happening in the past, you only

care can I get a code that works, right? In computer use, it's very different 'cause, uh, like we, we started to get customers two years ago, and all of the customer talk to me about this question, like, "Can I actually put your agents, uh, hosted, uh, in a server and run this workflow every day? And I don't have to, you know, keep looking at, uh, look-looking at, look-looking at what workflows. I don't have to debug in there." So basically, everyone was telling me about this metric, pass to the

power k. So this means I run this agent k times. Every time it needs to be successful. And this metric is not captured by any benchmark in there. And then we started to research this problem. So we took the best-performing agents in OS World, and th-their performance is pretty good in three different categories. And then we run the same agents three times. We measure the performance of pass to about, uh, to about three, right?

From this figure, you can see all the agents has degraded performance in there. They almost dropped ten percent success rate, even, even the best-performing agent in there. And the second part is on perturb environment, meaning my queries could be a little bit different, and environment could be a little bit different each time. And it, it get even worse. So, so this, this is still a problem in the computer's agents nowadays 'cause you can see, uh, Claude has, Codex has, uh, agents,

Claude has agents. None of the agents actually produce reliable, repeatable process for you.

So this is a recent paper we published, uh, like two months ago, so basically discussing this problem. And there's a little tr-- simple trick that we propose in this paper that everyone can, you know, can borrow the ideas in the future if you want your agents to be more reliable. The trick is basically ask the agent to, to ask you f- clarification, clarification questions when you give them the instruction. So, so basically th-this paper was saying like suppose the agent always asks you

some questions about ambi-ambiguous part in your, in your prompt, the reliability of the agent will be better. And there's a prompt in the, in the paper that everyone can look at it. Like, basically it's, it's, it's pretty simple. It's just like, okay, like your goal is to minimize, uh, uh, have minimum, uh, clarification that pr- still preserving the nature. So th-this line is very important. You put this prompt to the agent, and the agent can perform better.

After you put this clarification prompt to the agent, you can see, like, the overall, um, reliability of the agent is getting better. Like, uh, dashed line is the original performance with no clarification, and the solid line is the one with clarification, right? You can see Claude is getting better, and Agent S with GPT-5, which is interesting, has the biggest improvements. So, so the, the purple line is model-agnostic framework, and the green line is,

is the, you know, like, big labs computerized agents in there.

Okay. So, so basically, this is our journey for solving the VLM agent, which seems to be work, work, work pretty well. And still, like, nowadays, still people using the Agent S, uh, framework because model-agnostic, you can plug in any open source foundation models. I'm also, like, looking forward to getting, like, results with the latest open source big model like GLM, uh, 5.2 and see how the performance looks like in there. And then the second question is, okay, it doesn't solve the reliability problem, right? It, like, these, these agent

doesn't seem to be half... As long as you're using a neural net, as long as you use a VLM, it's in the end, in, at the end of the day, it's a probabilistic model. It produce a probability each time. So it's not gonna give you the same performance, uh, if you run it for, like, twenty-four seven every day. Then we had to think about what's the next thing to think about is, is basically symbolic layer. We call it coding agent. And we open source this, uh, language. We call

it SimuLang. Uh, it's a language for Simular. So we call it SimuLang there. So this language is kind of like if you're familiar with RPA industry, it's kind of like what RPA industry used to do, like they ask engineer to write a code. Uh, but the, the common problem for, uh, RPA is there's no single protocol that's shared across the whole community that everyone can use. And we try to create this, uh, uh, in, in browser automation, we have Playwright, which is, uh, in, in standard way. But in computer use, there's no, really no,

uh, industry standard there. So that's why we, we open source this. We hope it's helpful to all the developers, so you can, um, actually, like, build your own scripting layer for different workflows that's reliable, deterministic each time.

Yeah. So basically, the goal is to allow you to run, to create, uh, source code for SimuLang and run this code on your, in your terminal, and you can also use it in Claude Code. So I wa- I do wanna give you a quick demo in there. So let me... Okay.

Okay. So now I'm in, uh, Claude Code.

So if you install, um... Maybe I should show you

Simulang. Yeah. So these are the, the landing page, and if you go there, there's a simple one-line installer, NPM install. Once you install, you should be able to use it on your own terminal. And I'm a Claude Code user, so I like to s-see-- 'cause no one is writing code nowadays, right? It's important for you to use vibe coding to, to do this kind of automation. So once you install, there's a s-skill that you can-- is paired with, uh, Simulang, so you can just, uh, you know, use the skill.

So I can say go to AIE website and summarize the events.

Okay, so let's see how it works.

So now it's checking, checking version. So these are the logistic stuff. But it does understand it, it's gonna use Simulang to open AI Engineer World's Fair website.

Continue.

So you can notice it's, it's trying to use the Simulang JS as the JavaScript, uh, language.

And now Claude Code is gonna try to write some code using the Simulang protocol.

Yeah, I think it's because the, the Claude Code is new, so, um, it needs to do lots of, uh, logistic stuff.

I allow reading for everything.

So you can still think about this, this, uh, this is approach, it's a different approach for computers. It's basically reduce computer use problem into a, a coding problem in there. I have what I need, let me write a script that opens the website and extract the content in there. And then you can see the, the agent is writing the code. After that, it opens the website automatically on your... So, so Simulang is running on your own computer. If you have a virtual machine, you can

also deploy virtual machine in there.

So there's a...

And then, you know, after, after Claude Code run a, run a code, it recognize some errors. And after it gets the errors, it try to revise the code. So this is pretty much if you enable, you know, like auto-approval, this is pretty much already, um, a self-improving, uh, computers agents there. Some level of self, self-improving there.

I do want to see the...

It's not there.

Oh, it's here.

And you can see Claude Code is decided to use the accessibility snapshot instead of the scr-screenshot because, you know, it's a summarization task.

Okay, it's coming. It gets, uh, it actually summarize-- It did, yeah, it summarized all of the events for AI engineer in there. Okay, so I'll pause here, and I do want to show you the full code,

which could be interesting to look at.

Yeah, so these are the full code. It looks like JavaScript, uh, just like any, any other JavaScript. And it does open a window, take the snapshot, and write to the file. Yeah.

Okay. So let me go back to my presentation.

Okay, so, so I've, I've been talking about like two complete different approach. They are orthogonal. They're not the same, uh, same approach. But the question is do we actually need two frameworks in there? Right. So, so these things there, they try to compete with each other.

And this goes back to like a, like a very, uh, interesting and important topic in, in the whole deep learning 'cause, uh, uh, when I was in DeepMind, I specifically focusing on this problem called continual learning. So that's why we did a lot of study on like, uh, AI systems in there. But in the end, we realized, okay, there's no silver bullet. Like yeah, the, the-- when, when-- whatever technology you have, uh, like you have still have to solve the two problems as a trade-off.

Like the, the learning, any learning system needs to learn to new things, and any of the learning, uh, learning system needs to, you know, make sure you can accomplish the, the task that you, you, you're already successful, uh, repeatedly. So th-this become to-- it's called stability and plasticity dilemma. So you wa- you want the learning system to be stable, but at the same time, you want the learning system to, to have this capability to adapt, uh, adapt to new environments in there. It, it's never be the case that you, you are both, you are,

you're good at both. So that's the conclusion. Yeah, it's always trade-off. Then the, then, then the problem we can think about is how do we balance the two in there. And if you look at the two system I just demonstrated, these two systems are coding agents and V- uh, LLM agents, right? They, they basically representing the two extreme of this learning system. The coding agent produce the code, and it determines all the time, but it's kind of stubborn, right? If you run a code every day, if the environment changes, then the code breaks.

So that, that's the problem. And the LLM agent is kind of adaptive, but the problem is you cannot rely on the LLM agents to, uh, you know, like, repeat the process all the time. So the core question is, okay, c-can we find a middle ground between the two? 'Cause the north star is basically the best adaptivity and the best reliability, right? Can we-- We also call this, this curve, we call this curve Pareto front. And can, can we actually find, uh, the sweet spot there? So this becomes the current

direction that our company is specifically focusing on. Like, basically try to find a unified framework that we can combine these two into one single, single principle, which, which we call neuro-symbolic, right? 'Cause there's a neural then symbolic. Is there a way that we can actually like fuse these two technology into one single framework that it becomes self-improving all the time, and becomes robust when, when... Reliable when it's needed, becomes, uh, adaptive when environment changes? So I wouldn't say

we solved the problem. I wouldn't say we solved the problem, but, uh, I would say like we, we are already at the initial phase of moving towards this direction. 'Cause there's a clear paradigm that we can do right now. 'Cause we have, we have a VLM agent that's better than human in a small benchmark. And we have, uh, a coding protocol that we can actually write a code using a coding agent, and the protocol can produce deterministic workflows in there. This is a simple way

for us to do this new experiment. So basically, we, we let the VLM agent to run in the environment, and the agent keep writing the code to a file. And once this workflow is successful, you have a, you have a, you have a code that's, that's, uh, that's successful. And the next time we run the agent, you can run the code first instead of run the VLM agent. Right? I- if it doesn't work, if the environment changes, like when it breaks, uh, as,

as I just demonstrated, there's actually a healing loop that you can do with the coding agent. So this, this become very interesting. And, uh, yeah, I added this slide. So, so basically, another interesting, uh, story is, uh, this year's CalHacks, the- the- the same hackathon, the first place also used our, uh, our agent. But this time they u- they're not using the agent to build a product, they actually used the agent to test the product, which is another interesting

category that everyone can look at 'cause all of us are developers, right? We write code, and we know, like, nowadays there are more and more PRs, more and more code, then who's gonna do the testing? Then computer us- computer use agents is a solution for that. So basically, this is an agent that can just move in the mouse, click on the, uh, con- on the dashboard, and doing the testing for you. I'm not sure if I have time. If I have time, I really want to, uh, show a demo about like the, the testing part, but I can, I can try.

Let me try. Um, let me try to show you the loop that we have in the product. It's a, it's a initial effort. It works in a lot of cases, but sometimes it- there are still, uh, some hiccups in there. So, um,

I do look, I do look forward to everyone like testing the product and give us feedback in there.

Okay. So let me...

I'm not sure if this one is doing. Oh, this one, okay.

So this is the valid VM. Since the agent is now ...

You see I have, I have a lot of VMs here. And I, I do put different names to, to them. Um, so let me try this one, though.

So in order for you to enable the neuro-symbolic mode, you need to come to this dashboard, click on Agent. There are a lot of, uh, special, there are a lot of special algorithm we do, uh, here, like humanized control, like the trajectory is different, uh, clerical integration. So you need to look at the Simular Flow code replay. So th- this is a specific experiment we're doing right now. So the whole idea is, uh, basically the diagram I just showed. Uh, if we enable that, we can

try something. Let me ensure the desktop in there. Okay. So we can try this, uh, yeah, we can still try the, the simple thing. Just want to give you a rough idea of how this works. Go to

AIE webpage and, um, find the first speaker on Tuesday.

Uh, there's a...

Always has problem during live demo in there.

Let me restart agent.

Let me see if my VM is awake.

Yeah, while we're waiting, so let me show you, uh, another demo 'cause I al- I have a backup in there. If live demo needs long- longer time, so we can show, uh, another one. So this one is a collaboration with, uh, Microsoft. Uh, so Microsoft has, uh, Microsoft is also building this computer us- infrastructure, um, 'cause, 'cause they are the creator of Windows. So these are the VMs from Microsoft. It's called, uh, Microsoft Windows 365 for Agents. And the idea is...

F- from this, you can see like the, on the left side is chat. So the idea is, okay, like use, uh, use our agents on Microsoft virtual machines to f- to fill out the form on a traditional ERP. So th- this is one of the biggest area for computer u- computer use agents, 'cause, uh, there's still so many traditional industries, and they don't have modern APIs. They don't have like, you know, they're still running all the old- Um, softwares on their Windows machines, right? So if you have-- if you build out any

like applications that allow you to go to certain verticals, 'cause we are not vertical company and we are horizontal infrastructure, if you're interested in building like towards different verticals, these are good opportunities. Um, like for example, some of our customers, they, uh, they work with insurance website. They specifically work on insurance. So basically they use the agents go to insurance website and, uh, fetch the data. And some of them are healthcare. Uh, they work with doctors. They have uh, like doctors has Windows, uh, machines with ERP system,

very old, and you can use computer agents to automate all the da-data entry. So there's lots of ideas that, uh, people has been, uh, exploring in this direction. So, um, yeah. So those are hopefully that's, that, that'll give you some insights there.

Oh, it works. Yeah. So, so let me... 'Cause I guess I have some skills that's already there.

So there is a skill here.

Let me remove it.

Go to AIE website and see who's speaking first on Tuesday.

I already have website, so let me make a change. I create a new one.

And you can see all of the logs here.

And the interesting part, you can see this agent is writing, uh, almost like line by line, similar code. And after that it's gonna com-compose all of the code into one big file. Navigate into the schedule page. Okay, so you get the, get the information.

And if you notice, the agent is actually, it's not a screenshot. So whenever you try to find information, the agent actually decide, should I take a screenshot or should I take a accessibility tree? This time it's actually take a acce-accessibility tree, so you can see all the information that beneath in one shot in there. And what I can do now, 'cause I wanna show you that, uh, save to a skill.

So if I enable that neural symbolic mode, and I say save to skill, this skill will have all of the code that you just run in a, in a previous session. And then we can look at AI speaker on day... Let me find a skill. There.

I didn't find it though.

Okay, so this skill is saved, so I'll try a different query on a different day.

Let's try on Wednesday.

And you can see there's a replay mode showing up. The interface a little bit different 'cause, uh, it, it, it does have the code. It has the code, and it changes the parameter of the code. And if you click on the activity log, you can see the agent is actually producing a lot more code in the first step. So these are the, the code. It has like different parameters in there. Um, it, by default it's Tuesday, right? By default it's Tuesday. If you set it Wednesday,

it's gonna, uh, change the parameter there. And there's a hiccup. You can see there's a hiccup for the, the agent need to filter in there. It does find the information and replay successful in there. There's a little hiccup. And then after the hiccup, the agent, uh, convert it to the neural mode, which is the VLM agent. So the first time it always try to produce all of the code as much as

possible because if you have a pretty good hit rate, it's gonna have a very determinist, a very successful workflow. And then y- the agent also have verification in the middle. So every time it runs the code, it have verification. If there's something wrong, stop the... It's kinda like, it's kinda when, when, uh, back when I was, uh, when, when I was in sch- in school, we, we write everything that teacher says in the, in the memo as a playbook, right? And next time when I want to do something, I look at my memo and try to do

all the, you know, the steps step by step. And if the environment is different, I notice, okay, I, I try to do this action, but the environment doesn't allow me to do that. And then I have to like think more, spend more time on, you know, like exploring the new environment and try to figure out like what's the best strategy to do.

Okay, so let's move on. Uh, I believe that's a good direction for us to think for even for the whole industry to think about like what's the, what's the, uh, better, um, agents that we can produce with this kind of balance of, uh, flexibility and reliability. And we do see pretty good u- uh, success in this, this type of, uh, experiments. It's like, okay,

I don't-- I think it-- I think the main point is you don't have to spend the same amount of tokens each time anymore. With this kind of technology because, uh, because the second time we run the workflow, maybe fifty percent of it, the effort is done by code without any LM request in there, right? And, uh, you can, you can dramatically reduce your cost. So that's why we also experiment in this product. We also experiment with people on like, uh, five hundred dollars

unlimited task plan. So the pricing plan may also change. It's not gonna be like, uh, usage-based forever, uh, 'cause you think about like as a human, I'm, I'm a human. When I try to do a task a hundred times, I become so familiar with that, I can pretty much do all the things with my eyes closed, right? But today's agents, they don't have this capability. Every time you do the same task, even you do a thousand times or ten thousand times for the same task, even the same

query, you still pay the same amount of money to Anthropic and OpenAI, which doesn't seems to be like the, the reasonable, uh... It's, it's not economical as well. And yeah, so, uh, hopefully that, that give you a pretty good sense about what direction we're, we're going forward and, uh, I do encourage everyone to try, try it out 'cause we, we actively rapidly improving the neurosymbolic agents, uh, in the, in the, in the coming months. And, uh, hopefully we can achieve some like breakthrough in that direction.

And the second, second problem we have to think about is, okay, like what's the... What do we do with, with the computer? So two years ago, we st- we, we work on this autonomy, uh, technology on your computer. So basically we have a, we, we usually have a product that runs the agent kind of like cloud co-work, running on your own computer. But we receive a lot of complaint from users 'cause everyone has only one computer, and then when the agent's working on it, it's in foreground. You cannot, you cannot do anything. Yeah, so that actually motivates us to think

about, okay, suppose we have a human-level agent, uh, that works. Suppose we have something that works. It's not, it's not there yet. We-we're st- we're very close. But when that day comes, we have agent that works, then we have to think about what do we do with the computer. Like, do you still need one computer? Or maybe you need ten. So the current observation is whenever you have something that works, users always ask us to, "Can you, can you actually host this

agent on a separate machine? Can you host it on a server?" So th-this is always, always the same, uh, conclusion from most of the users. And then they will start to ask for more machines. So there's a trajectory. There's a trajectory. First, we are in the, in the, in the phase that we really try to make agents works. Once it works, you need ten machines or a hundred machines. That's why it motivates us to work on the cloud computers. Um, I'll, I'll briefly talk-- I already briefly

talked about it. I think that the whole point is if we have the cloud-managed desktop, uh, it becomes so scalable. And everyone in the end, I hope everyone can have a hundred computers, so you become the CEO of your own AI organization, right? So you have a hundred AI employees in there, and everyone become a hundred, uh, X productive. So yeah, basically this year, uh, we, we launched the product Sai in March. Uh, it's actually a pretty new product. And together with that is, is called Sai Box. It's the virtual

computer cloud in it. And from the, from, from that demo, you can already see I have personally, I have twenty machines, uh, running in the background in there. And, uh, this is a general diagram. Sai is actually the interface, and Sai calls the Sai agent, which, uh, do-- which does its autonomy, autonomy part, does the planning and decision, and then doing operations on the Sai Box, which is our cloud computer. And okay, and then we have a lot of friends who are developers, so they

keep asking us, "So can you actually expose the API?" So today we actually are releasing the API for, uh, accessing the, uh, the cloud computer. I don't think I have time to demo, but it's actually pretty simple. It's called SAPi, S-A-P-i, SAPi. And basically, you can do everything that I did in the web portal through your terminal, uh, using the CLI tools. And you can also use the-- there's also API tool in there. And, uh, we just released this website, so feel free to check it out. There's

lots of APIs, CLI. And once you sign up, you have a machine in the remote, uh, in remote setting. You can use this command line and API to, uh, control that computer and integrate your own product in it.

Yeah, I'll skip the live demo. So the, the general vision for this direction is we want, we want everyone to have one single agent, and this agent can access multiple platforms, not just Windows. So we also have, uh, uh, support on, on macOS. The Linux is coming soon. Linux is very, uh, economically friendly. It's, it's pretty cheap, uh, in, in terms of our pricing, uh, in, like based on our internal evaluation. And the interesting part is we also have Android. So Android is also coming soon. So I, I do

hope like in the future, you have a couple Android phones in the cloud, you have a couple Windows, and the agent actually can orchestrate among all of the device to doing all different tasks, uh, in there. And I wanna show some interesting demos for the Android. So these are all internal, uh, like evaluation. So this one is playing the Angry Bird game. And the interesting part is actually drag. Let me see. Yeah.

Yeah, it actually dragged, you know, it had the drag actions. It drag, drag the screen and doing the task in there. And another demo I feel pretty cool is the authenticator. So it actually goes to the authenticator and, uh, it's the same interface inside. Basically, we swap a Windows VM to an Android one. So let me make it faster

Yeah, it goes to this m- MFA authentication challenge

website, and fill out the forms there,

and then get the token.

Yeah, and then success. So, so th- this is, this is one of the problem that people keep asking us. Like, okay, like, "Can we do two FA?" It's still possible, and I do, I do see there's a, there's some value, but we have to use it in a, uh, with, like, uh, caution, caution there. And this is a example for, I believe the social media, uh, on the phone. Uh, like, you can actually do different kind of task there. Yeah, it's pretty exciting. I, I feel that Android is a, um, interesting area that,

like, the c- current industry hasn't really, like, explored much in it. There, there should be a lot of applications that we can do with, uh, Android, uh, virtual machines. So basically, everything is converged right now. So I started with autonomous computer, and I de- decomposed everything to autonomy and computer. And then autonomy be- becomes two parts, the neural part and symbolic part. Computer become local machines and cloud, cloud machines. So Sai actually solve for both. So you can actually, like, integrate your own machines to be part of the, you know, the fleet

in there, and you can also buy our cloud computers. And then everything become Sai, which is released, uh, in March this year. I'm pretty excited about this new product, and I hope, uh, that'll bring a lot of new opportunities, uh, uh, 'cause, 'cause this is something, like, I didn't imagine, like, two years ago. Like, we work on this technology. We don't know much about, like, what the vertical applica- application we can do. But we actually realized, okay, like, the... For example, there's a YC startup, uh, saw me in one of the event, and they tell me they

actually use Agent S for their own vertical applications. So I do see there's a huge opportunity that within, like, in the next year could be... In the next year, the tech- technology will be, uh, relatively... Based on the, the past estimation, the next year will be very i- interesting to, to see what, what's, what's gonna happen. And then what I can imagine, there are a lot of, uh, new applications, like, blossom in, in, in this, this domain in, uh, within a year, you know. Yeah,

basically to summary, we have four, uh, offering for all developers. Sai.work is the, the basically the whole interface. You can explore. You go to the different algorithm in the developer mode. Give it a try, let us know how it works, and we actively developing new technology in there. Agent S, Simulang, which is open sourced and everyone can use. It's pretty much free, uh, free to use. And SaiBox is the API for the, for the virtual desktop, and we just released today, so expect some bugs. Uh, do let us know. Uh,

and I'll, I'll give you the invitation code, uh, for, uh, today. It's AIEWF2026, and please give it a try. Let me know, uh, the feedback. We do have a credits program, like, uh, happy to collaborate in a diff- in different way, different capacity, and see how to, you know, like, uh, make your development better, uh, in the future. All right, thank you so much. Uh, I, I want to leave some time for questions, so feel free to, uh, ask me questions, you know.

And thank you for your patience. I'll, I'll make, I will make sure the photo is posted, so let me know if you want to be mentioned in there.

Yeah, feel free to ask any... I'll stay here, like, uh, for a few minutes, but I understand, like, uh, there's another event going there. Yeah.

Yeah, question?

So

are you using spatial memory in any way?

Spatial memory?

Yeah. So for VM, how, uh, it visually looks and memorizing that pattern.

For now, mo- most of the memory are reduced to text in there. Yeah. And we do have, as I mentioned in Agent S Two, we do have a model, separate model. So it's actually not a simple wrapper of a large, uh, vision language model. So we have other seven billion open source models. Sometimes we also, like, fine-tune in that model, and that model is specific responsible for recognizing the screen. And the interesting part is we know the foundation model is progressing so, so fast and so good, but it's still not

very good at understanding screen. So that's an interesting, yeah, interesting conclusion. Probably it's because the Internet doesn't have many, like, screenshot data, uh, available. So it's, so it's, it's not available for them to train the models in there. Um, but I can imagine the model get- getting better and better. But j- it's just like there's always a gap. If, if you have a model that can specific for your own application, you can fine-tune that model. It's always gonna be better than,

like, uh, like, a general model, uh, from big labs in there. Yeah, question.

Couple questions.

Yeah.

First one is, uh, what is the trade-off, like, when using, uh, for example, like, RLM models that do, like, a female code generation as your approach for, like, persistent code generation? Have you experienced with RLMs as part of the process? That's the first one.

Yeah, so, so let me answer, answer your first quen- que- first question first. And, uh, the demo I showed is the LM, right, generating the code, and this is, this is approach I call as stateless programming. So all of the past twenty years, we all do f- stateless programming, and the neurosymbolic approach, I call it stateful programming, meaning when you... every time you run one line of code, you look at the environment, look at the state, and the state actually change. So this is a, I, I believe this is a new paradigm

for programming in the future. So pro- programming will be more stateful in the future. And, uh, we, we tried LLM, and the problem is, this problem is essentially multimodal. Right. So, so accessibility can have some capab-capability of, you know, like some... But it's not-- It, it's still the same. It's-- There's no silver bullet. So some people argue you can do computer vision just for screenshots, just using screenshots. Some people say accessibility is good enough. Some people say DOM

is good enough. But in the end, after all of the evaluation, there is no silver bullet on everything. So you always has corner cases of one, which, uh, is not corner case of the second. So, so in the end, I think we are actually, actually taking a Waymo approach. Like, you have lidar, radar, and camera all at the same time, right? And some, some company, they may take the Tesla approach. Like, I, I just have camera and yeah. But if you look at today's self-driving car, uh, we do see a lot of Waymo, uh, running on the road

with better reliability there. It's just like you have multiple systems that help each other to, to make sure they don't make mistakes. Like, especially fatal mistake. You don't want a, uh, you don't want an agent go to your bank and add another zero when you send a check to other people in there. Second. Yeah.

Second question is, uh, so you talked about accessibility for OSes. But as like complex product like Monday.com or Salesforce or whatever, do they differ, like from an accessibility perspective, do you think as OSes? Because they're really complex.

Yeah. So, uh, the good part of our accessibility tree is that information is used to render the screen. So basically, that information has pretty much all of the information that's needed to render a screen. And if you can use that information, it's definitely more reliable. But there are some c- uh, cor-- there are still corner cases like the developer of that application can intentionally say, "This part do not expose in the, in the tree." So,

so you can still capture that in a screenshot, but you don't capture in accessibility. But you can imagine some applications like, uh, for example, LinkedIn has a lot of, uh, bot detection. They're, they're pretty much the... I used to tell a joke with my friends, like LinkedIn is, is the Turing test for AGI. Yeah, because, yeah, if, if LinkedIn doesn't recognize your agent as agent, then you pretty much achieve AGI because you pass the Turing test in there. 'Cause they're, they're in adversarial setting. And, uh, they have a lot of techniques

to detect, and like, this kind of, uh, accessibility could be one of them in there. Yeah.

So that's why you still need multiple, you know, combination of the modality. So yeah. Uh, uh, there, there's one person. I'll, I'll l- Yeah, I'll let that person ask question first. Yeah. Thank you.

Yeah. Thank you very much first of all. Um, so we're from Germany-

Uh-huh

... and, uh, we have a use case in Germany for the, yeah, in hospitals, um, where you take information and then, uh, yeah,

do a lot of things with them.

Mm-hmm.

But the question is, how reliable is, uh, all of that that you have shown today in the real world today when you compare it with the healthcare sector, for example? So you need very accurate information and very accurate processes.

Right.

What is your opinion on that?

Yeah. So, so basically the question is, uh, we need a very accurate information. So basically we need everything to be a hundred percent, right? So even when you do data entry, you need to be a hundred percent. So, uh, that problem is the biggest problem with the current foundation models, but we do have a solution for that. So it's basically a, a-- As, as you can see, everything's a loop, right? So all the, all the fundamental principles, everything's a loop. When you do something, you always verify, you criticize yourself. Uh, it's the same

for humans. So when I, when I propose some ideas to, to my friends, they all-- they criticize. So I have the loop, so I can like reason with less bias in there. So the, the accuracy problem can also solve b-by this approach. So we, we do have some experiments that... I can tell you one solution we did is, uh, uh, whenever you have something, you fill out the form, you take a form, reverse it, and ask the model, "Does that make sense?" Right? So ask the model to verify. If the mo-

Most of the time, the model recognize something wrong in there, 'cause ver-verification is, uh, is much easier than generation, generation, general action. And if there's something wrong, you take the results back and ask the agent to do the same task again. It actually improve the performance a lot. And, um, another thing you can think about is, uh, the accessibility tree. Like, for us to write the code and for the code to be deterministically replayed, you can only do in accessibility tree.

You cannot do in a screenshot, right? Because the tree is a text. Text can-- you can do a hundred percent matching there. So that kind of a hundred percent text matching is also important to ensure everything is, uh, uh, reliable. So in the end, the conclusion is, uh, you have to have a system. It's, it's not gonna be one model. You put it there, and then you can hope that's a hundred percent. It's not gonna happen in there. And, uh, but there's definitely a solution for your use case in there. Yeah. Sorry, uh,

your turn. Yeah.

Yeah. Uh, a big thank you for open sourcing-

Yeah

... some of those requests. We appreciate that. Um, I think with computer use agents, whenever I talk to people, they're always concerned about guardrails and security.

Mm-hmm.

Um, how do you kind of keep it from, you know, accessing things that you just don't want it to access? Like if I don't want it to look at, you know, the mail app, I only want it to use Chrome, and I only want it to go to particular websites.

Mm-hmm.

How do you kind of incorporate those guardrails into any product?

Yeah. So, so in the product side, we do have a guardrail. So whenever there's a action that recognize that irreversible action, the guardrail will say stop. There, so it's another system. Another system monitoring this agent. If the agent wanna do a certain action, it'll basically cut off and say, "Ask for approval." But I believe your, your problem is even more challenging. It's more at the low level of the operating system level. Like for example, the agent will say, "Open these applications," and you don't want this application to be

blocked in there, right? So this requires another layer, uh, on the OS level. That's why we believe have the cloud-managed, uh, Windows machine is a better direction because we have, we, we have the VM. So if you need, we can also produce, uh, the image, the VM image for you. So in a VM image, you have lots of opportunity to, uh, change the underlying, you know, structure of the operating system. So you can actually block some of the actions, have the whitelist in there. So

I believe that's the, that's the final direction. Uh, we are still early on the VM, uh, part. I-- we, we try to explore that direction and, uh, like, yeah, if you're interested, like we can also think about some partnership in the future, uh, on how to have better guardrails. Yeah, it's, it's definitely like a security, security guardrail is definitely like one important aspect in it. Yeah. Th-thanks.

Very, very quick.

Yeah.

Just the, um, detection of an irreversible action, how are you doing that for such something as robust as, like-

Yeah, yeah. So, so that, that's, that goes to the same principle. The, the first line I put in the-- basically, everything is neurosymbolic. If you want everything to be reliable, everything needs to be re- neurosymbolic. You always go to the code first 'cause code can guarantee you a hundred percent, right? When the code is confusing, you always go to the flexible agent and then come back, come back to the code. So that's why the code is still s-super important. It's the same principle for the design for the guardrail. So the guardrail is also like code first.

There are lots of rules happening there. Uh, if the rule doesn't capture, it goes to agent and then goes to human for verification and then comes back. Uh, it's a, it's a design principle that we try to follow in all of the system inside, uh, even every components, uh, in the, in the system. Yeah. Thanks. Question.

Yeah. So I mean, one of the things you talked about, you know, it'll first try the code, then it'll try the vision.

Yeah.

But as you get repeated cycles through the same workflow, the same interface, does it iterate to get more and more code so less and less dependent upon-

Right. Right. Right. So, so that's, that's the trajectory. So, so basically we want the token consumption to eventually become zero. Yeah. Eventually become zero. And you can see-- sometimes you can see the code actually start to have more branch-

Yeah

... showing, showing up. When you will see different scenarios, you see more... It's just like human learning, right? When you see, uh, you have more data samples, then you are less biased in terms of decision-making. Yeah. It's the same for this approach. Yeah.

Oh, so question.

Um, if a company has a proprietary program that they have to use or a legacy program-

Yeah

... and they run basically the same type of process a hundred times-

Right

... I can show you how it could, you know, write the code first and then you go basically have a script to redup-- do everything-

Mm-hmm

... like say, keep going through. On the initial prompt, do you have to be very specific? 'Cause like, 'cause it's never seen this program, go to employee, go to payroll, go to this, that, and this, check this box in the initial prompt. Or how do you like, if it's especially a long process, do you-- is that like a long prompt you put into it or how-- or do you actually like show it how to do something?

Yeah. For, for this version, you can see there's a prompt and the agent doing the task. Uh, well maybe in, in a couple months we, we also think about it's, it's, uh, it's pretty common in research community. So basically if you can replicate, like people talking about world models, right? If you can replicate these applications, uh, that you have better control on not doing, if you have guardrails, that, uh, the agent is not gonna do like bad things, and then you can do exploration. We call it exploration in the environment. So basically you let the agents do free

exploration on envi-environment for different, uh, like maybe a hundred times, and then the agent become more familiar with the environment. And then your, basically your prompt will be less, you, you don't need very accurate prompt, like whether this button or that button. You, you can al-also, also like succeed in terms of like, uh, finding the first-- Basically the goal is finding the first successful trajectory. Once you've found it, it can be successful all the time. Yeah.

If you already know that process, you can already tell it like this is the exact process-

Yeah

... of doing it. Just reiterate.

Yeah, yeah, yeah. Yeah. For, for many companies they call SOP. So yeah, they have internal, they have SOP. So we, we actually did an interesting experiment. We feed one SOP directly to the, uh, coding agent, right? And it one-shot, it one-shot everything, and it's suc- a hundred percent successful directly. So it's pos-- it's definitely possible, but I, I hold the, uh, the possibility that like everything now is still kind of demo phase.

We, we want the technology that's general enough that every customer come in here and we don't have to worry about anything breaks in there. So there's still lots of corner cases that we have to solve going forward. Yeah. Yeah. I remember there's one gentleman, uh, raised hand before. Yeah. Oh, okay. Yeah. Fine. Thank you. All right. Thanks so much. Oh, so one more.

Uh, well that's the question. That's, uh-- Thank you, uh, for your speaking today. And, uh, that was, uh, into the other question we had, uh, about using legacy, uh, old desktop application.

Uh-huh.

And actually I did the hackathon yesterday-

Uh-huh

... for this to use, and I would like to have your, uh, your, uh, your opinion on that.

Uh-huh.

Of the actual software. So, but it is, uh, uh, pixel-based, so you can see like, uh, uh, we are actually, uh, putting in the memory pixels and, and tap to certain, uh, uh, uh, things.

Oh.

So you can actually at the end an MCP to guide that computer user. So, uh, this mean, uh, the computer user don't even need to see in which screen he is. He just have to keep this current expression, expression, disposition to do a certain thing. Uh, I don't know if I'm, uh, clear about my explanation, but is it the thing that you're actually working on? Is it possible? I understood that you want to generalize the, the, the,

uh, how the agent is working, but, uh, is it, uh, still something, uh, you would be, uh, doing, uh, explain or no?

Yeah. Um, uh, I, I... So, uh, my impression is kind of like a map, and then you try to let the agent to walk through the map.

So he can just go blindly. He doesn't have to... If you ask him to, yeah, just add, uh, this user-

Uh-huh

... he doesn't need to read, uh, the, take screenshot, go there, figure out. Just have to map out how we should go, like, uh, where he should click to go there and that. So it doesn't cost the token. It's faster and everything.

Yeah. Yeah. So that, that's the whole idea of the coding layer. So the coding layer basically encode all of the trajectory into the code, right? And I think, I think the problem we try to solve is, uh, uh, suppose there's legacy software, then it's not gonna change, then this, this approach work. But if we talk about like, uh, websites, right? For social media or, like, different websites, and they actually change. And when they change, then your path is not gonna work in there. Is there a way for us to actually adapt, adapt

the agent, uh, during that scenario?

I, I mean, uh, my, my answer to that problem-

Uh-huh

... at the hackathon was if, uh, if your main, uh, computer, uh, agent, uh, is actually won't, uh, maybe encounter, encounter a problem-

Uh-huh

... it just release again like a swarm to check it out, like if it's, uh, if something has changed or anything. So you have a continuous improving on that map. So the map should not be fixed.

Uh-huh.

It should be like, uh, improving every time the agent has, uh, an issue with that.

Yeah. Yeah. Yeah. I get your point. So, so basically, his solution is, okay, every time there's a change, I have a swarm of agents doing the exploration in there, so I always know the, the best, uh-

So yes-

Yeah, the path in there

... you don't have to like, uh, actually like, uh, use the, the, the software like-

Yeah. Yeah. That, that's exactly my response to that gentleman. So the basic, the idea is if you have legacy system and you have... It's a zero cost for exploration, right? 'Cause for example, it's a, if it's a bank, then there's a cost for exploration. I cannot explore for all of the actions. But if you don't, you don't have any, like, cost for doing exploration, you just do exploration. I put agents in there and I let them try different things and map all of the trajectory there, and it's actually a simpler problem to

solve. So basically, I, I think eighty percent of the, the applications is actually living in the legacy system right now. And if we have-- You can s-- Like, it's, it's actually easier problem to the general, uh, system. So that can also already capture a lot of economic value in the current industry. Yeah. Yeah. Thanks for your feedback. Yeah. Further, furthermore.

The thing is that with enough data of similar, you can teach the visual signal eventually. You will have enough data-

Yeah. So, so the, the, the question is, suppose we have enough data, can we actually train, uh, train the agents to be very successful? So there was a, there was a lot of, uh, discussion around that. So basically, my conclusion is you need more exponentially more money than OpenAI and Anthropic to do it. Because, because, uh, vision data is two-dimensional. Text is one-dimensional. So we are talking about like something like much bigger,

right? So, so you, you, uh, if you have-- If you can give me like, uh, couple trillion dollars, uh, we can cer- we can certainly consider that. Yeah. But it's challenging. Maybe it's possible with the, with the new paradigm of... But gi-given the current paradigm of deep learning, it's not something that's, uh, like I don't think it's achievable in the near term right now. Yeah. Yeah. Ques- Final question.

Yeah. So the code is the trajectory essentially.

Right.

How does, does it properly have the right granularity? 'Cause I'm imagining like if I have this really long workflow, and it's coded out that entire process, there's a lot of space and a lot of spots where things can go wrong.

Right.

So how does it, uh, you know, how do you recommend the granularity of the code or the scripts? Like, uh, two, three steps and then it calls a new script, and then some next steps?

Oh, e-eventually your code will have a lot of if/else logic in there. So, so you can imagine the code is, the code is not gonna be manageable by humans, for sure. Uh, but the code is still be able-- The agent is still be able to write that code with lots of if/else, while loop, uh, complex logics in there, and it'll still work. And yeah, that, that's the eventual goal of this system in there. Yeah. But you can also chop it. Chop it to make it simple problems

each time. But then you have a boundary problem, like, okay, how do you define a smaller problem? Like, what's the boundary? What's the input and output, right? So sometimes you, if you have a simple solution, that's, that's actually even better.

All right. Thanks. Thank you, everyone.